mirrors/ghostty
1
0
Fork 0
mirror of https://github.com/ghostty-org/ghostty.git synced 2026-08-25 16:41:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

build: fix flatpak/snap, restore rpath opt, fix local gtk4-layer-shell (#13677)

Browse Source 
This fixes regressions in the flatpak/snap builds, and knock-on stuff
that was discovered as as a result:

* Update the Zig versions in the flatpak/snap build configuration files.
* Restore the classic `-Dpatch-rpath` option, and add a new
`-Dpatch-interp` option. This ensures that the snap can still use
`-Dpatch-rpath` correctly.
* There seems to be an issue in Zig when parsing IPv6 addresses that
leads to issues loading `resolv.conf` files; when trying to load a
nameserver that has an IPv6 address with a numeric interface index as
the scoped zone ID, Zig will try to resolve the interface as a name
rather than just use the index. This is coming up in snap builds because
the build process seems to, by default, use the exhaustive
`/run/systemd/resolve/resolv.conf` file, versus the simpler stub
(`stub-resolv.conf`) file. We work around this for the time being by
linking the stub at the end of the Zig part, overwriting the link to the
non-stub file.
* Fixed `gtk4-layer-shell` packaging - the migration to external
translate-c meant that non-system builds of the dependency were not
handing the local `gtk4-layer-shell` headers over for translation. Now,
instead, we've extracted the management of the `gtk4-layer-shell` source
and `wayland-protocols` generation to a locally-cached object so that
the source can be shared by both C translation and the library build in
a way that is not coupled to any particular step.
This commit is contained in:
Mitchell Hashimoto
2026-08-07 07:52:31 -07:00
committed by GitHub
parent faeac91fa5 b9113d2e7f
commit 0a78672e7c
4 changed files with 144 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
pkg/gtk4-layer-shell/build.zig
View File

@@ -39,18 +39,24 @@ pub fn build(b: *std.Build) !void {
else
link_system_libs_full[0..1],
});
if (!b.systemIntegrationOption("gtk4-layer-shell", .{})) {
// local deps (non-system layer-shell/wayland)
const deps = try LocalDeps.get(b) orelse break :translate;
headers.addIncludePath(deps.upstream.path("include"));
headers.addIncludePath(deps.upstream.path("src"));
headers.addIncludePath(deps.client_header_directory);
}
module.addImport("c", headers.mod);
}
if (!b.systemIntegrationOption("gtk4-layer-shell", .{})) {
_ = try buildLib(b, module, .{
.target = target,
.optimize = optimize,
});
_ = try buildLib(b, .{ .target = target, .optimize = optimize });
}
}
fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Build.Step.Compile {
fn buildLib(b: *std.Build, options: anytype) !*std.Build.Step.Compile {
const lib_version = try std.SemanticVersion.parse(version);
const target = options.target;
const optimize = options.optimize;
@@ -67,58 +73,20 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
});
b.installArtifact(lib);
// We need to call both lazy dependencies to tell Zig we need both
const upstream_ = b.lazyDependency("gtk4_layer_shell", .{});
const wayland_protocols_ = b.lazyDependency("wayland_protocols", .{});
const upstream = upstream_ orelse return lib;
const wayland_protocols = wayland_protocols_ orelse return lib;
lib.root_module.addIncludePath(upstream.path("include"));
lib.root_module.addIncludePath(upstream.path("src"));
module.addIncludePath(upstream.path("include"));
// GTK
lib.root_module.linkSystemLibrary("gtk4", dynamic_link_opts);
// Wayland headers and source files
{
const protocols = [_]struct { []const u8, std.Build.LazyPath }{
.{
"wlr-layer-shell-unstable-v1",
upstream.path("protocol/wlr-layer-shell-unstable-v1.xml"),
},
.{
"xdg-shell",
wayland_protocols.path("stable/xdg-shell/xdg-shell.xml"),
},
// Even though we don't use session lock, we still need its headers
.{
"ext-session-lock-v1",
wayland_protocols.path("staging/ext-session-lock/ext-session-lock-v1.xml"),
},
};
const wf = b.addWriteFiles();
for (protocols) |protocol| {
const name, const xml = protocol;
const header_scanner = b.addSystemCommand(&.{ "wayland-scanner", "client-header" });
header_scanner.addFileArg(xml);
_ = wf.addCopyFile(
header_scanner.addOutputFileArg(name),
b.fmt("{s}-client.h", .{name}),
);
const source_scanner = b.addSystemCommand(&.{ "wayland-scanner", "private-code" });
source_scanner.addFileArg(xml);
const source = source_scanner.addOutputFileArg(b.fmt("{s}.c", .{name}));
lib.root_module.addCSourceFile(.{ .file = source });
}
lib.root_module.addIncludePath(wf.getDirectory());
// local deps (non-system layer-shell/wayland)
const deps = try LocalDeps.get(b) orelse return lib;
lib.root_module.addIncludePath(deps.upstream.path("include"));
lib.root_module.addIncludePath(deps.upstream.path("src"));
lib.root_module.addIncludePath(deps.client_header_directory);
for (deps.private_code_files) |source| {
lib.root_module.addCSourceFile(.{ .file = source });
}
lib.installHeadersDirectory(
upstream.path("include"),
deps.upstream.path("include"),
"",
.{ .include_extensions = &.{".h"} },
);
@@ -134,7 +102,7 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
"xdg-surface-server.c",
};
lib.root_module.addCSourceFiles(.{
.root = upstream.path("src"),
.root = deps.upstream.path("src"),
.files = srcs,
.flags = &.{
b.fmt("-DGTK_LAYER_SHELL_MAJOR={}", .{lib_version.major}),
@@ -145,3 +113,68 @@ fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Bu
return lib;
}
const LocalDeps = struct {
var cached: ?LocalDeps = null;
upstream: *std.Build.Dependency,
wayland_protocols: *std.Build.Dependency,
client_header_directory: std.Build.LazyPath,
private_code_files: []std.Build.LazyPath,
fn init(b: *std.Build) !?LocalDeps {
var result: LocalDeps = .{
.upstream = b.lazyDependency("gtk4_layer_shell", .{}) orelse return null,
.wayland_protocols = b.lazyDependency("wayland_protocols", .{}) orelse return null,
.client_header_directory = undefined,
.private_code_files = &.{},
};
// Wayland headers and source files
{
const protocols = [_]struct { []const u8, std.Build.LazyPath }{
.{
"wlr-layer-shell-unstable-v1",
result.upstream.path("protocol/wlr-layer-shell-unstable-v1.xml"),
},
.{
"xdg-shell",
result.wayland_protocols.path("stable/xdg-shell/xdg-shell.xml"),
},
// Even though we don't use session lock, we still need its headers
.{
"ext-session-lock-v1",
result.wayland_protocols.path("staging/ext-session-lock/ext-session-lock-v1.xml"),
},
};
const wf = b.addWriteFiles();
const private_code_files = try b.allocator.alloc(std.Build.LazyPath, protocols.len);
for (protocols, 0..) |protocol, idx| {
const name, const xml = protocol;
const header_scanner = b.addSystemCommand(&.{ "wayland-scanner", "client-header" });
header_scanner.addFileArg(xml);
_ = wf.addCopyFile(
header_scanner.addOutputFileArg(name),
b.fmt("{s}-client.h", .{name}),
);
const source_scanner = b.addSystemCommand(&.{ "wayland-scanner", "private-code" });
source_scanner.addFileArg(xml);
const source = source_scanner.addOutputFileArg(b.fmt("{s}.c", .{name}));
private_code_files[idx] = source;
}
result.private_code_files = private_code_files;
result.client_header_directory = wf.getDirectory();
}
cached = result;
return result;
}
fn get(b: *std.Build) !?LocalDeps {
if (cached) |c| return c;
return init(b);
}
};