/gtk-adwaita/build.zig at 5f1a9e504d4130893fd46a76940692cf85b643a4

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

//! This file defines how `zig build` command behaves.
//! Run `zig build --help` for available subcommands and options.
//!
//! Learn more at
//! https://ziglang.org/learn/build-system/

const std = @import("std");

const BuildError = error{
    NonValaSourceInSourceListError,
};

const app_name = "jp.pocka.plac.gtk-adwaita";
const glib_schemas_dir = "share/glib-2.0/schemas";
const glib_compiled_schema_name = "gschemas.compiled";

pub fn build(b: *std.Build) !void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    const freelog = b.option(bool, "freelog", "Enable logging memory releases") orelse false;
    const compile_gschema = b.option(bool, "compile-gschema", "Compile gschema XML file for local run") orelse false;

    const core = core: {
        const dep = b.dependency("core", .{
            .target = target,
            .optimize = optimize,
            .freelog = freelog,
        });

        break :core dep.artifact("plac_glib");
    };

    // Vala source codes to compile.
    const vala_sources: [][]const u8 = vala_sources: {
        var list = std.ArrayList([]const u8).init(b.allocator);

        var dir = try std.fs.cwd().openDir("src", .{ .iterate = true });
        defer dir.close();

        var walker = try dir.walk(b.allocator);
        defer walker.deinit();

        while (try walker.next()) |entry| {
            const ext = std.fs.path.extension(entry.basename);
            if (std.mem.eql(u8, ".vala", ext)) {
                try list.append(b.dupe(entry.path));
            }
        }

        break :vala_sources try list.toOwnedSlice();
    };

    // System libraries to link.
    const system_libraries = [_][]const u8{
        "gtk4",
        "libadwaita-1",
        // Neither GTK4 nor Libadwaita provides SVG rendering. We need to use librsvg for
        // that purpose, whilst undocumented.
        "librsvg-2.0",
        "gee-0.8",
    };

    // A directory containing C source files compiled from Vala source code.
    // If you use this LazyPath in your artifact, the artifact automatically depends on
    // this Vala to C complication step. You don't have to manually `a.dependOn()`.
    const vala_cdir = vala: {
        const valac = b.addSystemCommand(&.{"valac"});

        // Tell Vala compiler to emit C rather than compile using system C compiler.
        valac.addArg("--ccode");

        // Vala's GTK binding incorrectly mark `Gtk.StyleContext` as deprecated, even though
        // its static method `add_provider_for_display` is the only future proof way to add
        // CSS. As Vala compiler has no CLI flag or magic comment to suppress specific use of
        // "deprecated" API, I resorted to suppress entire deprecation warnings. This has risk
        // of accidentally using deprecated API. It's still better than getting used to see
        // warnings on build and starting to ignore warnings.
        valac.addArg("--enable-deprecated");

        // Vala compiler uses GResource XML to statically check attributes.
        valac.addArg("--gresources");
        valac.addFileArg(b.path("data/gresource.xml"));

        valac.addArg("--vapidir");
        valac.addDirectoryArg(core.getEmittedIncludeTree());

        // Tell Vala what system libraries to use. Perhaps type checking things?
        for (system_libraries) |lib| {
            valac.addArgs(&.{ "--pkg", lib });
        }

        valac.addArgs(&.{ "--pkg", "posix" });
        valac.addArgs(&.{ "--pkg", "plac" });

        // Tell Vala to emit C source files under the output directory.
        // The directory usually is Zig cache directory (like ".zig-cache/o/xxx").
        // For example, when there is "src/Foo.vala", this step produces
        // ".zig-cache/o/hash-or-something-idk/vala/src/Foo.c"
        valac.addArg("--directory");
        const dir = valac.addOutputDirectoryArg("vala");

        // Let valac emit C source code without "src/" prefix.
        valac.addArg("--basedir");
        valac.addDirectoryArg(b.path("src"));

        // Vala compiler takes a list of Vala source files, then process them all.
        for (vala_sources) |src| {
            valac.addFileArg(b.path(b.pathJoin(&.{ "src", src })));
        }

        const t = b.addInstallDirectory(.{
            .source_dir = dir,
            .install_dir = .{ .custom = "src" },
            .install_subdir = "",
        });
        const step = b.step("valac", "Compile C source code from Vala files for debugging purpose");
        step.dependOn(&t.step);

        break :vala dir;
    };

    const gresouce_c = gresource: {
        const compiler = b.addSystemCommand(&.{"glib-compile-resources"});

        compiler.addArg("--sourcedir");
        compiler.addDirectoryArg(b.path("data"));

        compiler.addFileArg(b.path("data/gresource.xml"));

        compiler.addArg("--target");
        const built_c = compiler.addOutputFileArg("gresource.c");

        compiler.addArg("--dependency-file");
        _ = compiler.addDepFileOutputArg("resource.d");

        compiler.addArg("--generate-source");

        break :gresource built_c;
    };

    const gschema_compiled = gschema: {
        const compiler = b.addSystemCommand(&.{"glib-compile-schemas"});

        compiler.addArg("--targetdir");
        const out = compiler.addOutputDirectoryArg("compiled");

        compiler.addArg("--strict");

        compiler.addDirectoryArg(b.path("data/"));

        compiler.addFileInput(b.path(b.fmt("data/{s}.gschema.xml", .{app_name})));

        break :gschema out.path(b, glib_compiled_schema_name);
    };

    // An executable.
    const exe = exe: {
        const exe = b.addExecutable(.{
            .name = app_name,
            .target = target,
            .optimize = optimize,
        });

        // This is a standard C application, so libc is required.
        exe.linkLibC();

        // Vala does not bundle system libraries (of course): we have to tell the
        // linker.
        for (system_libraries) |lib| {
            exe.linkSystemLibrary(lib);
        }

        exe.linkLibrary(core);

        exe.addCSourceFile(.{ .file = gresouce_c });

        // At this point, build does not run yet—we can't enumerate C source
        // directory. Since we already have a list of Vala source code, we can
        // build a list of paths of to-be-generated C source file.
        for (vala_sources) |src| {
            // Basically unreachable. Don't put non Vala source into `vala_sources`.
            if (!std.mem.endsWith(u8, src, ".vala")) {
                return BuildError.NonValaSourceInSourceListError;
            }

            // Looks fragile but it works. Even if it produced incorrect paths,
            // filesystem and Zig compiler will tell us a file is missing.
            const rel_path = b.fmt("{s}.c", .{src[0..(src.len - 5)]});

            // src = "src/Foo.vala"
            // rel_path = "src/Foo.c"
            // file = "(step cache directory)/vala/src/Foo.c"
            exe.addCSourceFile(.{
                .file = try vala_cdir.join(b.allocator, rel_path),
            });
        }

        break :exe exe;
    };

    const install_compiled_gschema = b.addInstallFile(
        gschema_compiled,
        b.pathJoin(&.{ glib_schemas_dir, glib_compiled_schema_name }),
    );

    // 256x256 PNG icon (required for `.DirIcon`, icon file specific for AppImage)
    const icon_png256 = icon_png256: {
        const rsvg_convert = b.addSystemCommand(&.{"rsvg-convert"});

        rsvg_convert.addArgs(&.{ "--width=256", "--height=256" });
        rsvg_convert.addArg("--output");
        const output = rsvg_convert.addOutputFileArg(b.fmt("{s}.png", .{app_name}));

        // Input filename must be the last argument.
        rsvg_convert.addFileArg(b.path("data/app-icon.svg"));

        break :icon_png256 output;
    };

    // Default install step
    {
        const step = b.getInstallStep();

        // Application binary
        b.installArtifact(exe);

        // GLib schema file
        b.installFile(
            b.fmt("data/{s}.gschema.xml", .{app_name}),
            b.pathJoin(&.{ glib_schemas_dir, b.fmt("{s}.gschema.xml", .{app_name}) }),
        );

        // GLib schema file (compiled)
        if (compile_gschema) {
            step.dependOn(&install_compiled_gschema.step);
        }

        // Desktop entry
        b.installFile(
            "data/plac.desktop",
            b.pathJoin(&.{ "share/applications", b.fmt("{s}.desktop", .{app_name}) }),
        );

        // Icons
        b.installFile(
            "data/app-icon.svg",
            b.pathJoin(&.{ "share/icons/hicolor/16x16/apps", b.fmt("{s}.svg", .{app_name}) }),
        );
        step.dependOn(&b.addInstallFile(
            icon_png256,
            b.pathJoin(&.{ "share/icons/hicolor/256x256/apps", b.fmt("{s}.png", .{app_name}) }),
        ).step);
    }

    // Download linuxdeploy tool (AppImage)
    const linuxdeploy = linuxdeploy: {
        const tool = b.addExecutable(.{
            .name = "download-linuxdeploy",
            .root_source_file = b.path("build/download_linuxdeploy.zig"),
            .target = b.graph.host,
            .optimize = .Debug,
        });

        const run = b.addRunArtifact(tool);
        run.addArg("--tool-version=1-alpha-20250213-2");
        run.addArg(b.fmt("--cpu-arch={s}", .{@tagName(target.result.cpu.arch)}));
        break :linuxdeploy run.addPrefixedOutputFileArg("--out=", "linuxdeploy.AppImage");
    };

    const appimage = appimage: {
        const tool = b.addExecutable(.{
            .name = "build_appimage",
            .root_source_file = b.path("build/build_appimage.zig"),
            .target = b.graph.host,
            .optimize = .Debug,
        });

        const run = b.addRunArtifact(tool);
        run.addPrefixedFileArg("--linuxdeploy=", linuxdeploy);

        run.addPrefixedFileArg("--exe=", exe.getEmittedBin());

        run.addPrefixedFileArg("--desktop-entry=", b.path("data/plac.desktop"));

        run.addPrefixedFileArg("--icon=", icon_png256);

        _ = run.addPrefixedOutputDirectoryArg("--appdir=", "AppDir");

        break :appimage run.addPrefixedOutputFileArg("--out=", "Plac.AppImage");
    };

    // AppImage
    if (b.graph.host.result.os.tag == .linux) {
        const install = b.addInstallFile(appimage, "Plac.AppImage");
        const step = b.step("appimage", "Build AppImage bundle");
        step.dependOn(&install.step);
    }

    // `zig build run`
    {
        const run = b.addRunArtifact(exe);
        run.step.dependOn(&install_compiled_gschema.step);
        run.setEnvironmentVariable("GSETTINGS_SCHEMA_DIR", b.pathJoin(&.{ b.install_path, glib_schemas_dir }));
        const step = b.step("run", "Build and run Plac GTK-Adwaita app");
        step.dependOn(&run.step);
    }
}