diff options
| author | Can Celik <ogulcancelik@gmail.com> | 2026-04-04 19:22:04 +0300 |
|---|---|---|
| committer | Can Celik <ogulcancelik@gmail.com> | 2026-04-05 01:23:06 +0300 |
| commit | 41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch) | |
| tree | 3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/src/os/locale.zig | |
| parent | 55c138263e190a1e79d4b997bfb9397306c0ec1f (diff) | |
feat: finish ghostty pane backend integration
Diffstat (limited to 'vendor/libghostty-vt/src/os/locale.zig')
| -rw-r--r-- | vendor/libghostty-vt/src/os/locale.zig | 219 |
1 files changed, 219 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/src/os/locale.zig b/vendor/libghostty-vt/src/os/locale.zig new file mode 100644 index 00000000..faba3bd2 --- /dev/null +++ b/vendor/libghostty-vt/src/os/locale.zig @@ -0,0 +1,219 @@ +const std = @import("std"); +const builtin = @import("builtin"); +const assert = @import("../quirks.zig").inlineAssert; +const macos = @import("macos"); +const objc = @import("objc"); +const internal_os = @import("main.zig"); +const i18n = internal_os.i18n; + +const log = std.log.scoped(.os_locale); + +/// Ensure that the locale is set. +pub fn ensureLocale(alloc: std.mem.Allocator) !void { + assert(builtin.link_libc); + + // Get our LANG env var. We use this many times but we also need + // the original value later. + const lang = try internal_os.getenv(alloc, "LANG"); + defer if (lang) |v| v.deinit(alloc); + + // On macOS, pre-populate the LANG env var with system preferences. + // When launching the .app, LANG is not set so we must query it from the + // OS. When launching from the CLI, LANG is usually set by the parent + // process. + if (comptime builtin.target.os.tag.isDarwin()) { + // Set the lang if it is not set or if its empty. + if (lang == null or lang.?.value.len == 0) { + setLangFromCocoa(); + } + } + + // Set the locale to whatever is set in env vars. + if (setlocale(LC_ALL, "")) |v| { + log.info("setlocale from env result={s}", .{v}); + return; + } + + // setlocale failed. This is probably because the LANG env var is + // invalid. Try to set it without the LANG var set to use the system + // default. + if ((try internal_os.getenv(alloc, "LANG"))) |old_lang| { + defer old_lang.deinit(alloc); + if (old_lang.value.len > 0) { + // We don't need to do both of these things but we do them + // both to be sure that lang is either empty or unset completely. + _ = internal_os.setenv("LANG", ""); + _ = internal_os.unsetenv("LANG"); + + if (setlocale(LC_ALL, "")) |v| { + log.info("setlocale after unset lang result={s}", .{v}); + + // If we try to setlocale to an unsupported locale it'll return "C" + // as the POSIX/C fallback, if that's the case we want to not use + // it and move to our fallback of en_US.UTF-8 + if (!std.mem.eql(u8, std.mem.sliceTo(v, 0), "C")) return; + } + } + } + + // Failure again... fallback to en_US.UTF-8 + log.warn("setlocale failed with LANG and system default. Falling back to en_US.UTF-8", .{}); + if (setlocale(LC_ALL, "en_US.UTF-8")) |v| { + _ = internal_os.setenv("LANG", "en_US.UTF-8"); + log.info("setlocale default result={s}", .{v}); + return; + } else log.warn("setlocale failed even with the fallback, uncertain results", .{}); +} + +/// This sets the LANG environment variable based on the macOS system +/// preferences selected locale settings. +fn setLangFromCocoa() void { + const pool = objc.AutoreleasePool.init(); + defer pool.deinit(); + + // The classes we're going to need. + const NSLocale = objc.getClass("NSLocale") orelse { + log.warn("NSLocale class not found. Locale may be incorrect.", .{}); + return; + }; + + // Get our current locale and extract the language code ("en") and + // country code ("US") + const locale = NSLocale.msgSend(objc.Object, objc.sel("currentLocale"), .{}); + const lang = locale.getProperty(objc.Object, "languageCode"); + const country = locale.getProperty(objc.Object, "countryCode"); + + if (lang.value == null or country.value == null) { + log.warn("languageCode or countryCode not found. Locale may be incorrect.", .{}); + return; + } + + // Get our UTF8 string values + const c_lang = lang.getProperty([*:0]const u8, "UTF8String"); + const c_country = country.getProperty([*:0]const u8, "UTF8String"); + + // Convert them to Zig slices + const z_lang = std.mem.sliceTo(c_lang, 0); + const z_country = std.mem.sliceTo(c_country, 0); + + // Format our locale as "<lang>_<country>.UTF-8" and set it as LANG. + { + var buf: [128]u8 = undefined; + const env_value = std.fmt.bufPrintZ(&buf, "{s}_{s}.UTF-8", .{ z_lang, z_country }) catch |err| { + log.warn("error setting locale from system. err={}", .{err}); + return; + }; + log.info("detected system locale={s}", .{env_value}); + + // Set it onto our environment + if (internal_os.setenv("LANG", env_value) < 0) { + log.warn("error setting locale env var", .{}); + return; + } + } + + // Get our preferred languages and set that to the LANGUAGE + // env var in case our language differs from our locale. + language: { + var buf: [1024]u8 = undefined; + const pref_ = preferredLanguageFromCocoa( + &buf, + NSLocale, + ) catch |err| { + log.warn("error getting preferred languages. err={}", .{err}); + break :language; + }; + + const pref = pref_ orelse break :language; + log.debug( + "setting LANGUAGE from preferred languages value={s}", + .{pref}, + ); + _ = internal_os.setenv("LANGUAGE", pref); + } +} + +/// Sets the LANGUAGE environment variable based on the preferred languages +/// as reported by NSLocale. +/// +/// macOS has a concept of preferred languages separate from the system +/// locale. The set of preferred languages is a list in priority order +/// of what translations the user prefers. A user can have, for example, +/// "fr_FR" as their locale but "en" as their preferred language. This would +/// mean that they want to use French units, date formats, etc. but they +/// prefer English translations. +/// +/// gettext uses the LANGUAGE environment variable to override only +/// translations and a priority order can be specified by separating +/// the languages with colons. For example, "en:fr" would mean that +/// English translations are preferred but if they are not available +/// then French translations should be used. +/// +/// To further complicate things, Apple reports the languages in BCP-47 +/// format which is not compatible with gettext's POSIX locale format so +/// we have to canonicalize them. +fn preferredLanguageFromCocoa( + buf: []u8, + NSLocale: objc.Class, +) error{NoSpaceLeft}!?[:0]const u8 { + var fbs = std.io.fixedBufferStream(buf); + const writer = fbs.writer(); + + // We need to get our app's preferred languages. These may not + // match the system locale (NSLocale.currentLocale). + const preferred: *macos.foundation.Array = array: { + const ns = NSLocale.msgSend( + objc.Object, + objc.sel("preferredLanguages"), + .{}, + ); + break :array @ptrCast(ns.value); + }; + for (0..preferred.getCount()) |i| { + var str_buf: [255:0]u8 = undefined; + const str = preferred.getValueAtIndex(macos.foundation.String, i); + const c_str = str.cstring(&str_buf, .utf8) orelse { + // I don't think this can happen but if it does then I want + // to know about it if a user has translation issues. + log.warn("failed to convert a preferred language to UTF-8", .{}); + continue; + }; + + // Append our separator if we have any previous languages + if (fbs.pos > 0) { + _ = writer.writeByte(':') catch + return error.NoSpaceLeft; + } + + // Apple languages are in BCP-47 format, and we need to + // canonicalize them to the POSIX format. + const canon = try i18n.canonicalizeLocale( + fbs.buffer[fbs.pos..], + c_str, + ); + fbs.seekBy(@intCast(canon.len)) catch unreachable; + + // The canonicalized locale never contains the encoding and + // all of our translations require UTF-8 so we add that. + _ = writer.writeAll(".UTF-8") catch return error.NoSpaceLeft; + } + + // If we had no preferred languages then we return nothing. + if (fbs.pos == 0) return null; + + // Null terminate it + _ = writer.writeByte(0) catch return error.NoSpaceLeft; + + // Get our slice, this won't be null terminated so we have to + // reslice it with the null terminator. + const slice = fbs.getWritten(); + return slice[0 .. slice.len - 1 :0]; +} + +const c = @import("locale-c"); +const LC_ALL: c_int = c.LC_ALL; +const LC_ALL_MASK: c_int = c.LC_ALL_MASK; +const locale_t = c.locale_t; +const setlocale = c.setlocale; +const newlocale = c.newlocale; +const freelocale = c.freelocale; |
