Something went wrong. Try again.
An example of how to hack DVUI and layer shell protocol together.
Something went wrong. Try again.
15 kB · 369 lines
Zig
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370const std = @import("std");const dvui = @import("dvui");const SDLBackend = @import("backend");const builtin = @import("builtin");const wayland = @import("wayland").client;const WaylandContext = @import("waylandContext.zig");
pub const InitOptions = SDLBackend.InitOptions;pub const WindowGeometry = SDLBackend.WindowGeometry;const c = SDLBackend.c;const log = std.log.scoped(.SDLCustomBackend);
const SDL_ERROR = bool;const SDL_SUCCESS: SDL_ERROR = true;const sdl3 = true;
pub fn initWindow(init_options: InitOptions, alloc: std.mem.Allocator) !struct { const Self = @This(); backend: SDLBackend, waylandCtx: *WaylandContext,} { try initSDL(); const new = try createWindowRenderer(init_options, alloc);
var back = SDLBackend.init(init_options.io, new.win, new.renderer); back.init_opts_save = init_options; back.window_geometry = new.saved_geometry orelse .{};
try configureBackend(&back, init_options);
return .{ .backend = back, .waylandCtx = new.waylandCtx, };}
/// SDL initialization for the all SDL app, i.e. common for all OS Windows/// This is expected to be called only once.pub fn initSDL() !void { // use the string version instead of the #define so we compile with SDL < 2.24 _ = c.SDL_SetHint("SDL_HINT_WINDOWS_DPI_SCALING", "1");
// makes mac scrolling better _ = c.SDL_SetHint(c.SDL_HINT_MAC_SCROLL_MOMENTUM, "1");
// prevents some bad performance in certain wayland compositors (sway) under some conditions if (c.SDL_SetHint(c.SDL_HINT_VIDEO_WAYLAND_PREFER_LIBDECOR, "1") != SDL_SUCCESS) { log.err("failed to set libdecor hint", .{}); }
try toErr(c.SDL_Init(c.SDL_INIT_VIDEO | c.SDL_INIT_EVENTS), "SDL_Init in initWindow");
// FIXME : as per SDL docs : // Consider reporting some basic metadata about your application before calling SDL_Init, using either SDL_SetAppMetadata() or SDL_SetAppMetadataProperty(). // This would be nice here probably ...}
fn createWindowRenderer(options: InitOptions, alloc: std.mem.Allocator) !struct { win: *c.SDL_Window, renderer: *c.SDL_Renderer, saved_geometry: ?WindowGeometry, waylandCtx: *WaylandContext,} { var hidden = options.hidden; var show_window_in_begin = false; if (dvui.accesskit_enabled and !hidden) { // hide the window until we can initialize accesskit in Window.begin hidden = true; show_window_in_begin = true; }
const saved_geometry: ?WindowGeometry = if (sdl3) WindowGeometry.load(options) else null;
const hidden_flag = if (hidden) c.SDL_WINDOW_HIDDEN else 0; const fullscreen_flag = if (options.fullscreen) c.SDL_WINDOW_FULLSCREEN else 0; const transparent_flag = if (options.transparent and sdl3) c.SDL_WINDOW_TRANSPARENT else 0; const window: *c.SDL_Window = if (sdl3) blk: { // Window properties let us apply restored geometry at creation time, // so the window appears directly at its previous position/size. const props = c.SDL_CreateProperties(); defer c.SDL_DestroyProperties(props);
const flags: c.SDL_WindowFlags = @intCast(c.SDL_WINDOW_HIGH_PIXEL_DENSITY | c.SDL_WINDOW_RESIZABLE | transparent_flag | hidden_flag | fullscreen_flag); var w: c_int = @as(c_int, @trunc(options.size.w)); var h: c_int = @as(c_int, @trunc(options.size.h));
if (saved_geometry) |g| { w = g.w; h = g.h; if (posOnADisplay(g)) { try toErr(c.SDL_SetNumberProperty(props, c.SDL_PROP_WINDOW_CREATE_X_NUMBER, g.x), "SDL_SetNumberProperty in initWindow"); try toErr(c.SDL_SetNumberProperty(props, c.SDL_PROP_WINDOW_CREATE_Y_NUMBER, g.y), "SDL_SetNumberProperty in initWindow"); } }
try toErr(c.SDL_SetStringProperty(props, c.SDL_PROP_WINDOW_CREATE_TITLE_STRING, options.title), "SDL_SetStringProperty in initWindow"); try toErr(c.SDL_SetNumberProperty(props, c.SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, w), "SDL_SetNumberProperty in initWindow"); try toErr(c.SDL_SetNumberProperty(props, c.SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, h), "SDL_SetNumberProperty in initWindow"); try toErr(c.SDL_SetNumberProperty(props, c.SDL_PROP_WINDOW_CREATE_FLAGS_NUMBER, @intCast(flags)), "SDL_SetNumberProperty in initWindow");
try toErr(c.SDL_SetBooleanProperty(props, c.SDL_PROP_WINDOW_CREATE_WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN, true), "SDL_SetBooleanProperty in initWindow"); try toErr(c.SDL_SetBooleanProperty(props, c.SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN, true), "SDL_SetBooleanProperty in initWindow"); try toErr(c.SDL_SetBooleanProperty(props, c.SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN, true), "SDL_SetBooleanProperty in initWindow");
break :blk c.SDL_CreateWindowWithProperties(props) orelse return logErr("SDL_CreateWindowWithProperties in initWindow"); } else c.SDL_CreateWindow( options.title, c.SDL_WINDOWPOS_UNDEFINED, c.SDL_WINDOWPOS_UNDEFINED, @as(c_int, @trunc(options.size.w)), @as(c_int, @trunc(options.size.h)), @intCast(c.SDL_WINDOW_ALLOW_HIGHDPI | c.SDL_WINDOW_RESIZABLE | hidden_flag), ) orelse return logErr("SDL_CreateWindow in initWindow");
errdefer c.SDL_DestroyWindow(window);
const waylandCtx = try WaylandContext.init(window, .{ .h = @trunc(options.size.h), .w = @trunc(options.size.w) }, alloc); errdefer waylandCtx.deinit(alloc);
// get initial content scale var scale: f32 = 1.0; if (sdl3) { scale = c.SDL_GetDisplayContentScale(c.SDL_GetDisplayForWindow(window)); if (scale == 0) { log.err("SDL_GetDisplayContentScale returned 0", .{}); scale = 1.0; } log.info("SDL3 backend scale {d}", .{scale}); } else { // scale = SDL2GuessScale(options.environ_map, options.io, window); // sdl2_scale = scale; }
// adjust window size for content scale if (scale != 1.0 and saved_geometry == null) { if (builtin.abi.isAndroid()) { // log.error fails on Android but SDL_Log will show up in LogCat c.SDL_Log("[ERROR] Android doesn't support SDL_SetWindowSize"); } else { _ = c.SDL_SetWindowSize( window, @as(c_int, @trunc(scale * options.size.w)), @as(c_int, @trunc(scale * options.size.h)), ); } }
if (options.min_size) |size| { if (builtin.abi.isAndroid()) { // log.error fails on Android but SDL_Log will show up in LogCat c.SDL_Log("[ERROR] Android doesn't support SDL_SetWindowMinimumSize"); } else { const ret = c.SDL_SetWindowMinimumSize( window, @as(c_int, @trunc(scale * size.w)), @as(c_int, @trunc(scale * size.h)), ); if (sdl3) try toErr(ret, "SDL_SetWindowMinimumSize in initWindow"); } }
if (options.max_size) |size| { if (builtin.abi.isAndroid()) { // log.error fails on Android but SDL_Log will show up in LogCat c.SDL_Log("[ERROR] Android doesn't support SDL_SetWindowMaximumSize"); } else { const ret = c.SDL_SetWindowMaximumSize( window, @as(c_int, @trunc(scale * size.w)), @as(c_int, @trunc(scale * size.h)), ); if (sdl3) try toErr(ret, "SDL_SetWindowMaximumSize in initWindow"); } }
const renderer: *c.SDL_Renderer = if (!sdl3) c.SDL_CreateRenderer(window, -1, @intCast( c.SDL_RENDERER_TARGETTEXTURE | (if (options.vsync) c.SDL_RENDERER_PRESENTVSYNC else 0), )) orelse return logErr("SDL_CreateRenderer in initWindow") else blk: { const props = c.SDL_CreateProperties(); defer c.SDL_DestroyProperties(props);
try toErr( c.SDL_SetPointerProperty(props, c.SDL_PROP_RENDERER_CREATE_WINDOW_POINTER, window), "SDL_SetPointerProperty in initWindow", );
if (options.vsync) { try toErr( c.SDL_SetNumberProperty(props, c.SDL_PROP_RENDERER_CREATE_PRESENT_VSYNC_NUMBER, 1), "SDL_SetNumberProperty in initWindow", ); }
break :blk c.SDL_CreateRendererWithProperties(props) orelse return logErr("SDL_CreateRendererWithProperties in initWindow"); }; errdefer c.SDL_DestroyRenderer(renderer);
// do premultiplied alpha blending: // * rendering to a texture and then rendering the texture works the same // * any filtering happening across pixels won't bleed in transparent rgb values const pma_blend = c.SDL_ComposeCustomBlendMode(c.SDL_BLENDFACTOR_ONE, c.SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, c.SDL_BLENDOPERATION_ADD, c.SDL_BLENDFACTOR_ONE, c.SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, c.SDL_BLENDOPERATION_ADD); try toErr(c.SDL_SetRenderDrawBlendMode(renderer, pma_blend), "SDL_SetRenderDrawBlendMode in initWindow");
// do fullscreen/maximize after window creation so the original geometry is saved: // position window -> fullscreen -> quit -> restart -> unfullscreen should restore original position if (!options.hidden) { if (saved_geometry) |g| { switch (g.state) { .normal => {}, .maximized => { _ = c.SDL_MaximizeWindow(window); }, .fullscreen => { if (sdl3) _ = c.SDL_SetHint(c.SDL_HINT_VIDEO_MAC_FULLSCREEN_MENU_VISIBILITY, "1"); _ = c.SDL_SetWindowFullscreen(window, true); }, } } }
return .{ .win = window, .renderer = renderer, .saved_geometry = saved_geometry, .waylandCtx = waylandCtx, };}
fn configureBackend(back: *SDLBackend, options: InitOptions) !void { var hidden = options.hidden; var show_window_in_begin = false; if (dvui.accesskit_enabled and !hidden) { // hide the window until we can initialize accesskit in Window.begin hidden = true; show_window_in_begin = true; } back.ak_should_initialized = show_window_in_begin; back.we_own_window = true; back.clear_window_on_begin = true;
if (options.icon) |bytes| { if (builtin.abi.isAndroid()) { // log.error fails on Android but SDL_Log will show up in LogCat c.SDL_Log("[ERROR] Android doesn't support setting a custom icon at runtime"); } else { try back.setIconFromFileContent(bytes); } }}
const State = enum { normal, maximized, fullscreen };
const Saved = struct { x: i32, y: i32, w: i32, h: i32, state: State = .normal,};
const zon_file_name = "window_geometry.zon";
fn filePath(buf: []u8, options: InitOptions) ?[:0]const u8 { if (options.pref_path) |dir| { if (std.mem.endsWith(u8, dir, std.fs.path.sep_str)) { return std.fmt.bufPrintZ(buf, "{s}{s}", .{ dir, zon_file_name }) catch null; } return std.fmt.bufPrintZ(buf, "{s}{c}{s}", .{ dir, std.fs.path.sep, zon_file_name }) catch null; } const pref = c.SDL_GetPrefPath(options.org.ptr, options.title.ptr) orelse { logErr("SDL_GetPrefPath in WindowGeometry") catch {}; return null; }; defer c.SDL_free(pref); return std.fmt.bufPrintZ(buf, "{s}" ++ zon_file_name, .{std.mem.span(@as([*:0]const u8, @ptrCast(pref)))}) catch null;}
fn fromSaved(saved: Saved) ?WindowGeometry { if (saved.w < 1 or saved.h < 1) return null; return .{ .x = std.math.cast(c_int, saved.x) orelse return null, .y = std.math.cast(c_int, saved.y) orelse return null, .w = std.math.cast(c_int, saved.w) orelse return null, .h = std.math.cast(c_int, saved.h) orelse return null, .state = saved.state, };}
fn toSaved(self: WindowGeometry) Saved { return .{ .x = @intCast(self.x), .y = @intCast(self.y), .w = @intCast(self.w), .h = @intCast(self.h), .state = self.state, };}
pub fn load(options: InitOptions) ?WindowGeometry { if (!options.persist_window_geometry) return null; var path_buf: [1024]u8 = undefined; const path = filePath(&path_buf, options) orelse return null; return loadZon(options.io, path);}
fn loadZon(io: std.Io, path: [:0]const u8) ?WindowGeometry { const data = std.Io.Dir.cwd().readFileAlloc(io, path, std.heap.page_allocator, .limited(4096)) catch return null; defer std.heap.page_allocator.free(data); var nul_buf: [4097]u8 = undefined; if (data.len >= nul_buf.len) return null; @memcpy(nul_buf[0..data.len], data); nul_buf[data.len] = 0; const saved = std.zon.parse.fromSlice( Saved, std.heap.page_allocator, nul_buf[0..data.len :0], null, .{ .ignore_unknown_fields = true }, ) catch return null; return fromSaved(saved);}
fn writeFile(io: std.Io, path: [:0]const u8, g: WindowGeometry) void { var aw = std.Io.Writer.Allocating.init(std.heap.page_allocator); defer aw.deinit(); std.zon.stringify.serialize(g.toSaved(), .{}, &aw.writer) catch return; const parent = std.fs.path.dirname(path) orelse return; std.Io.Dir.createDirAbsolute(io, parent, .default_dir) catch {}; std.Io.Dir.cwd().writeFile(io, .{ .sub_path = path, .data = aw.written() }) catch { log.err("failed to write window_geometry.zon", .{}); };}
fn save(back: *SDLBackend) void { const opts = back.init_opts_save orelse return; var path_buf: [1024]u8 = undefined; const path = filePath(&path_buf, opts) orelse return;
//std.debug.print("saving window geometry: {any}\n", .{back.window_geometry}); WindowGeometry.writeFile(opts.io, path, back.window_geometry);}
/// True if the window's title bar area would land on a connected display./// Guards against restoring onto a monitor that is no longer attached.fn posOnADisplay(self: WindowGeometry) bool { var count: c_int = 0; const displays = c.SDL_GetDisplays(&count) orelse return false; defer c.SDL_free(displays); const cx = self.x + @divTrunc(self.w, 2); const cy = self.y + 10; for (displays[0..@intCast(count)]) |id| { var bounds: c.SDL_Rect = undefined; if (!c.SDL_GetDisplayUsableBounds(id, &bounds)) continue; if (cx >= bounds.x and cx < bounds.x + bounds.w and cy >= bounds.y and cy < bounds.y + bounds.h) return true; } return false;}
inline fn toErr(res: SDL_ERROR, what: []const u8) !void { if (res == SDL_SUCCESS) return; return logErr(what);}
inline fn logErr(what: []const u8) dvui.Backend.GenericError { log.err("{s} failed, error={s}", .{ what, c.SDL_GetError() }); return dvui.Backend.GenericError.BackendError;}