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

// Copyright 2025 Shota FUJI <pockawoooh@gmail.com>
//
// 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

const std = @import("std");

const Variant = @import("./variant.zig").Variant;

const GnomeColorScheme = enum(c_int) {
    default = 0,
    @"prefer-dark" = 1,
    @"prefer-light" = 2,

    pub fn from_variant(variant: Variant) @This() {
        return switch (variant) {
            .system => .default,
            .dark => .@"prefer-dark",
            .light => .@"prefer-light",
        };
    }
};

pub const ApplyError = error{
    FailedToSpawnProcess,
    GsettingsCommandUnexpectedlyTerminated,
};

pub fn apply(allocator: std.mem.Allocator, variant: Variant) ApplyError!void {
    const gnome_color_scheme = GnomeColorScheme.from_variant(variant);

    const run_result = std.process.Child.run(.{
        .allocator = allocator,
        .argv = &.{
            "gsettings",
            "set",
            "org.gnome.desktop.interface",
            "color-scheme",
            @tagName(gnome_color_scheme),
        },
    }) catch |err| {
        std.log.err("Failed to run gsettings command: {s}", .{@errorName(err)});
        return ApplyError.FailedToSpawnProcess;
    };
    defer allocator.free(run_result.stdout);
    defer allocator.free(run_result.stderr);

    if (run_result.stderr.len > 0) {
        var stdout_writer = std.fs.File.stderr().writer(&.{});
        const stdout = &stdout_writer.interface;

        stdout.writeAll(run_result.stderr) catch |err| {
            std.log.err("Failed to write to stderr: {t}", .{err});
        };
    }

    switch (run_result.term) {
        .Exited => |code| {
            if (code != 0) {
                std.log.err("Non zero exit: {d}", .{code});
                return ApplyError.GsettingsCommandUnexpectedlyTerminated;
            }
        },
        .Signal => |sig| {
            std.log.err("Signal ({d})", .{sig});
            return ApplyError.GsettingsCommandUnexpectedlyTerminated;
        },
        else => {
            std.log.err("Process terminated abnormally", .{});
            return ApplyError.GsettingsCommandUnexpectedlyTerminated;
        },
    }

    std.log.info("Set GNOME color scheme to {s}", .{@tagName(gnome_color_scheme)});
}