1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88

// Copyright 2025 Shota FUJI
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
//
// SPDX-License-Identifier: MPL-2.0

const std = @import("std");

const CompileVala = @import("./build/CompileVala.zig");
const manifest = @import("./build.zig.zon");

const app_name = "jp.pocka.timetracker";

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

    const version = b.option(
        []const u8,
        "version",
        "Application version. Defaults to `version` field in \"build.zig.zon\".",
    ) orelse manifest.version;

    const app_id = b.option(
        []const u8,
        "app-id",
        b.fmt("Application ID. Defaults to \"{s}\"", .{app_name}),
    ) orelse app_name;

    // System libraries to link.
    const system_libraries = [_][]const u8{
        "glib-2.0",
        "gtk4",
        "libadwaita-1",
    };

    const vala_main = vala_main: {
        var compile = try CompileVala.init(b, .{
            .src = b.path("src"),
            .includeTestFiles = false,
        });

        for (system_libraries) |lib| {
            compile.addPackage(lib);
        }

        compile.addPackage("posix");
        compile.addPackage("Config");

        compile.addVapi(b.path("src/Config.vapi"));

        const step = b.step("valac", "Compile C source code from Vala files for debugging purpose");
        step.dependOn(compile.step);

        break :vala_main compile;
    };

    const exe = exe: {
        const exe = b.addExecutable(.{
            .name = app_name,
            .root_module = b.createModule(.{
                .link_libc = true,
                .target = target,
                .optimize = optimize,
            }),
        });

        exe.root_module.addCMacro("APP_VERSION", b.fmt("\"{s}\"", .{version}));
        exe.root_module.addCMacro("APP_ID", b.fmt("\"{s}\"", .{app_id}));

        for (system_libraries) |lib| {
            exe.linkSystemLibrary(lib);
        }

        for (vala_main.compiled_c_files) |file| {
            exe.addCSourceFile(.{ .file = file });
        }

        break :exe exe;
    };

    // Default install step
    {
        b.installArtifact(exe);
    }
}