pogmommy/multibg-wayland
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Format code

Browse source
This commit is contained in:
Gergő Sályi 2025-04-23 15:21:51 +02:00
parent 7be93dacac
commit decaa33752
11 changed files with 156 additions and 209 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
rustfmt.toml Normal file
View file

@ -0,0 +1,19 @@
# This project doesn't use rustfmt, these are only for hints with
# rustfmt --check src/file.rs
doc_comment_code_block_width = 80
edition = "2021"
format_code_in_doc_comments = true
format_macro_matchers = true
format_strings = true
group_imports = "StdExternalCrate"
imports_granularity = "Crate"
match_arm_blocks = false
match_block_trailing_comma = true
max_width = 80
reorder_impl_items = true
style_edition = "2021"
trailing_semicolon = false
use_field_init_shorthand = true
use_small_heuristics = "Max"
wrap_comments = true

22
src/compositors.rs
View file

@ -33,16 +33,15 @@ impl Compositor {
debug!("Selecting compositor Sway based on {xdg_desktop_var}"); debug!("Selecting compositor Sway based on {xdg_desktop_var}");
Some(Compositor::Sway) Some(Compositor::Sway)
} else if xdg_desktop.as_bytes().starts_with(b"Hyprland") { } else if xdg_desktop.as_bytes().starts_with(b"Hyprland") {
debug!("Selecting compositor Hyprland based on {xdg_desktop_var}"); debug!("Selecting compositor Hyprland based on {}",
xdg_desktop_var);
Some(Compositor::Hyprland) Some(Compositor::Hyprland)
} else if xdg_desktop.as_bytes().starts_with(b"niri") { } else if xdg_desktop.as_bytes().starts_with(b"niri") {
debug!("Selecting compositor Niri based on {xdg_desktop_var}"); debug!("Selecting compositor Niri based on {xdg_desktop_var}");
Some(Compositor::Niri) Some(Compositor::Niri)
} else { } else {
warn!( warn!("Unrecognized compositor from {xdg_desktop_var} \
"Unrecognized compositor from {xdg_desktop_var} \ environment variable: {xdg_desktop:?}");
environment variable: {xdg_desktop:?}"
);
None None
} }
} else { } else {
@ -107,7 +106,11 @@ pub struct ConnectionTask {
} }
impl ConnectionTask { impl ConnectionTask {
pub fn new(composer: Compositor, tx: Sender<WorkspaceVisible>, waker: Arc<Waker>) -> Self { pub fn new(
composer: Compositor,
tx: Sender<WorkspaceVisible>,
waker: Arc<Waker>,
) -> Self {
let interface: Box<dyn CompositorInterface> = match composer { let interface: Box<dyn CompositorInterface> = match composer {
Compositor::Sway => Box::new(sway::SwayConnectionTask::new()), Compositor::Sway => Box::new(sway::SwayConnectionTask::new()),
Compositor::Hyprland => Box::new( Compositor::Hyprland => Box::new(
@ -135,7 +138,8 @@ impl ConnectionTask {
composer_interface.subscribe_event_loop(event_sender); composer_interface.subscribe_event_loop(event_sender);
} }
Compositor::Hyprland => { Compositor::Hyprland => {
let composer_interface = hyprland::HyprlandConnectionTask::new(); let composer_interface =
hyprland::HyprlandConnectionTask::new();
composer_interface.subscribe_event_loop(event_sender); composer_interface.subscribe_event_loop(event_sender);
} }
Compositor::Niri => { Compositor::Niri => {
@ -164,7 +168,9 @@ impl ConnectionTask {
} }
pub fn request_visible_workspaces(&mut self) { pub fn request_visible_workspaces(&mut self) {
for workspace in self.interface.request_visible_workspaces().into_iter() { for workspace in self.interface
.request_visible_workspaces().into_iter()
{
self.tx self.tx
.send(WorkspaceVisible { .send(WorkspaceVisible {
output: workspace.output, output: workspace.output,

2
src/compositors/hyprland.rs
View file

@ -10,7 +10,7 @@ use std::{
use log::debug; use log::debug;
use serde::Deserialize; use serde::Deserialize;
use super::{CompositorInterface, WorkspaceVisible, EventSender}; use super::{CompositorInterface, EventSender, WorkspaceVisible};
pub struct HyprlandConnectionTask {} pub struct HyprlandConnectionTask {}

2
src/compositors/niri.rs
View file

@ -3,7 +3,7 @@ use std::io;
use log::debug; use log::debug;
use niri_ipc::{socket::Socket, Event, Request, Response, Workspace}; use niri_ipc::{socket::Socket, Event, Request, Response, Workspace};
use super::{CompositorInterface, WorkspaceVisible, EventSender}; use super::{CompositorInterface, EventSender, WorkspaceVisible};
pub struct NiriConnectionTask {} pub struct NiriConnectionTask {}

9
src/compositors/sway.rs
View file

@ -1,4 +1,4 @@
use super::{CompositorInterface, WorkspaceVisible, EventSender}; use super::{CompositorInterface, EventSender, WorkspaceVisible};
use swayipc::{Connection, Event, EventType, WorkspaceChange}; use swayipc::{Connection, Event, EventType, WorkspaceChange};
pub struct SwayConnectionTask { pub struct SwayConnectionTask {
@ -8,7 +8,9 @@ pub struct SwayConnectionTask {
impl SwayConnectionTask { impl SwayConnectionTask {
pub fn new() -> Self { pub fn new() -> Self {
SwayConnectionTask { SwayConnectionTask {
sway_conn: Connection::new().expect("Failed to connect to sway socket. If you're not using sway, pass the correct --compositor argument. Original cause"), sway_conn: Connection::new().expect("Failed to connect to sway \
socket. If you're not using sway, pass the correct \
--compositor argument. Original cause"),
} }
} }
} }
@ -28,7 +30,8 @@ impl CompositorInterface for SwayConnectionTask {
} }
fn subscribe_event_loop(self, event_sender: EventSender) { fn subscribe_event_loop(self, event_sender: EventSender) {
let event_stream = self.sway_conn.subscribe([EventType::Workspace]).unwrap(); let event_stream = self.sway_conn
.subscribe([EventType::Workspace]).unwrap();
for event_result in event_stream { for event_result in event_stream {
let event = event_result.unwrap(); let event = event_result.unwrap();
let Event::Workspace(workspace_event) = event else { let Event::Workspace(workspace_event) = event else {

10
src/gpu.rs
View file

@ -16,11 +16,7 @@ use std::{
use anyhow::Context; use anyhow::Context;
use ash::{ use ash::{
Device, Entry, Instance, Device, Entry, Instance,
ext::{ ext::{debug_report, debug_utils, image_drm_format_modifier},
debug_report,
debug_utils,
image_drm_format_modifier,
},
khr::external_memory_fd, khr::external_memory_fd,
vk::{ vk::{
Buffer, Buffer,
@ -82,7 +78,7 @@ impl Gpu {
fn select_device( fn select_device(
&mut self, &mut self,
dmabuf_drm_dev: Option<Dev> dmabuf_drm_dev: Option<Dev>,
) -> Option<Rc<GpuDevice>> { ) -> Option<Rc<GpuDevice>> {
let mut ret = None; let mut ret = None;
self.devices.retain(|weak_gpu_device| { self.devices.retain(|weak_gpu_device| {
@ -254,7 +250,7 @@ impl GpuMemory {
pub fn dmabuf_feedback_eq( pub fn dmabuf_feedback_eq(
&self, &self,
dmabuf_drm_dev: Option<Dev>, dmabuf_drm_dev: Option<Dev>,
drm_format_modifiers: &[u64] drm_format_modifiers: &[u64],
) -> bool { ) -> bool {
self.gpu_device.dmabuf_drm_dev_eq(dmabuf_drm_dev) self.gpu_device.dmabuf_drm_dev_eq(dmabuf_drm_dev)
&& drm_format_modifiers.contains(&self.drm_format_modifier) && drm_format_modifiers.contains(&self.drm_format_modifier)

8
src/gpu/device.rs
View file

@ -1,5 +1,5 @@
use std::{ use std::{
ffi::{CStr, c_char}, ffi::{c_char, CStr},
rc::Rc, rc::Rc,
}; };
@ -12,11 +12,7 @@ use ash::{
physical_device_drm, physical_device_drm,
queue_family_foreign, queue_family_foreign,
}, },
khr::{ khr::{driver_properties, external_memory_fd, image_format_list},
driver_properties,
external_memory_fd,
image_format_list,
},
vk::{ vk::{
self, self,
api_version_variant, api_version_variant,

10
src/image.rs
View file

@ -30,7 +30,7 @@ pub struct WallpaperFile {
} }
pub fn output_wallpaper_files( pub fn output_wallpaper_files(
output_dir: &Path output_dir: &Path,
) -> anyhow::Result<Vec<WallpaperFile>> { ) -> anyhow::Result<Vec<WallpaperFile>> {
let dir = read_dir(output_dir).context("Failed to read directory")?; let dir = read_dir(output_dir).context("Failed to read directory")?;
let mut ret = Vec::new(); let mut ret = Vec::new();
@ -197,9 +197,8 @@ fn copy_pad_stride(
height: usize, height: usize,
) { ) {
for row in 0..height { for row in 0..height {
dst[row * dst_stride..][..src_stride].copy_from_slice( dst[row * dst_stride..][..src_stride]
&src[row * src_stride..][..src_stride] .copy_from_slice(&src[row * src_stride..][..src_stride]);
);
} }
} }
@ -210,8 +209,7 @@ fn swizzle_bgra_from_rgb(src: &[u8], dst: &mut [u8]) {
unsafe { unsafe {
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
if is_x86_feature_detected!("avx2") { if is_x86_feature_detected!("avx2") {
bgra_from_rgb_avx2(src, dst, pixel_count); return bgra_from_rgb_avx2(src, dst, pixel_count)
return
} }
bgra_from_rgb(src, dst, pixel_count) bgra_from_rgb(src, dst, pixel_count)
} }

20
src/main.rs
View file

@ -1,5 +1,5 @@
mod compositors;
mod cli; mod cli;
mod compositors;
mod gpu; mod gpu;
mod image; mod image;
mod poll; mod poll;
@ -42,8 +42,8 @@ use smithay_client_toolkit::reexports::protocols
use crate::{ use crate::{
cli::{Cli, PixelFormat}, cli::{Cli, PixelFormat},
compositors::{Compositor, ConnectionTask, WorkspaceVisible}, compositors::{Compositor, ConnectionTask, WorkspaceVisible},
image::ColorTransform,
gpu::Gpu, gpu::Gpu,
image::ColorTransform,
poll::{Poll, Waker}, poll::{Poll, Waker},
signal::SignalPipe, signal::SignalPipe,
wayland::BackgroundLayer, wayland::BackgroundLayer,
@ -160,8 +160,7 @@ fn run() -> anyhow::Result<()> {
shm_format, shm_format,
background_layers: Vec::new(), background_layers: Vec::new(),
compositor_connection_task: ConnectionTask::new( compositor_connection_task: ConnectionTask::new(
compositor, compositor, tx.clone(), Arc::clone(&waker)
tx.clone(), Arc::clone(&waker)
), ),
color_transform, color_transform,
dmabuf_state, dmabuf_state,
@ -240,7 +239,7 @@ fn flush_blocking(event_queue: &EventQueue<State>) {
fn ensure_prepare_read( fn ensure_prepare_read(
state: &mut State, state: &mut State,
event_queue: &mut EventQueue<State> event_queue: &mut EventQueue<State>,
) -> ReadEventsGuard { ) -> ReadEventsGuard {
loop { loop {
if let Some(guard) = event_queue.prepare_read() { return guard } if let Some(guard) = event_queue.prepare_read() { return guard }
@ -263,24 +262,23 @@ fn handle_sway_event(
state: &mut State, state: &mut State,
rx: &Receiver<WorkspaceVisible>, rx: &Receiver<WorkspaceVisible>,
) { ) {
while let Ok(workspace) = rx.try_recv() while let Ok(workspace) = rx.try_recv() {
{
// Find the background layer that of the output where the workspace is // Find the background layer that of the output where the workspace is
if let Some(affected_bg_layer) = state.background_layers.iter_mut() if let Some(affected_bg_layer) = state.background_layers.iter_mut()
.find(|bg_layer| bg_layer.output_name == workspace.output) .find(|bg_layer| bg_layer.output_name == workspace.output)
{ {
affected_bg_layer.draw_workspace_bg(&workspace.workspace_name); affected_bg_layer.draw_workspace_bg(&workspace.workspace_name);
} } else {
else {
error!( error!(
"Workspace '{}' is on an unknown output '{}', known outputs were: {}", "Workspace '{}' is on an unknown output '{}', \
known outputs were: {}",
workspace.workspace_name, workspace.workspace_name,
workspace.output, workspace.output,
state.background_layers.iter() state.background_layers.iter()
.map(|bg_layer| bg_layer.output_name.as_str()) .map(|bg_layer| bg_layer.output_name.as_str())
.collect::<Vec<_>>().join(", ") .collect::<Vec<_>>().join(", ")
); );
continue; continue
}; };
} }
} }

2
src/signal.rs
View file

@ -135,7 +135,7 @@ unsafe fn sigaction_set_handler(
signum: c_int, signum: c_int,
handler: extern "C" fn(c_int), handler: extern "C" fn(c_int),
mask: sigset_t, mask: sigset_t,
flags: c_int flags: c_int,
) -> io::Result<()> { ) -> io::Result<()> {
unsafe { unsafe {
if sigaction( if sigaction(

261
src/wayland.rs
View file

@ -57,8 +57,7 @@ use crate::{
image::{load_wallpaper, output_wallpaper_files, WallpaperFile}, image::{load_wallpaper, output_wallpaper_files, WallpaperFile},
}; };
impl CompositorHandler for State impl CompositorHandler for State {
{
fn scale_factor_changed( fn scale_factor_changed(
&mut self, &mut self,
_conn: &Connection, _conn: &Connection,
@ -218,8 +217,7 @@ impl DmabufHandler for State {
} }
} }
impl LayerShellHandler for State impl LayerShellHandler for State {
{
fn closed( fn closed(
&mut self, &mut self,
_conn: &Connection, _conn: &Connection,
@ -246,19 +244,14 @@ impl LayerShellHandler for State
self.compositor_connection_task self.compositor_connection_task
.request_visible_workspace(&bg_layer.output_name); .request_visible_workspace(&bg_layer.output_name);
debug!( debug!("Configured layer on output: {}, new surface size {}x{}",
"Configured layer on output: {}, new surface size {}x{}",
bg_layer.output_name, bg_layer.output_name,
configure.new_size.0, configure.new_size.1 configure.new_size.0, configure.new_size.1);
); } else {
} debug!("Ignoring configure for already configured layer \
else { on output: {}, new surface size {}x{}",
debug!(
"Ignoring configure for already configured layer on output: {}, \
new surface size {}x{}",
bg_layer.output_name, bg_layer.output_name,
configure.new_size.0, configure.new_size.1 configure.new_size.0, configure.new_size.1);
);
} }
} }
} }
@ -274,35 +267,29 @@ impl OutputHandler for State {
qh: &QueueHandle<Self>, qh: &QueueHandle<Self>,
output: WlOutput, output: WlOutput,
) { ) {
let Some(info) = self.output_state.info(&output) let Some(info) = self.output_state.info(&output) else {
else {
error!("New output has no output info, skipping"); error!("New output has no output info, skipping");
return; return
}; };
let Some(output_name) = info.name let Some(output_name) = info.name else {
else {
error!("New output has no name, skipping"); error!("New output has no name, skipping");
return; return
}; };
let Some((width, height)) = info.modes.iter() let Some((width, height)) = info.modes.iter()
.find(|mode| mode.current) .find(|mode| mode.current)
.map(|mode| mode.dimensions) .map(|mode| mode.dimensions)
else { else {
error!( error!("New output {} has no current mode set, skipping",
"New output '{}' has no current mode set, skipping", output_name);
output_name return
);
return;
}; };
if !width.is_positive() || !height.is_positive() { if !width.is_positive() || !height.is_positive() {
error!( error!("New output {} has non-positive resolution: {} x {}, \
"New output '{}' has non-positive resolution: {} x {}, skipping", skipping", output_name, width, height);
output_name, width, height return
);
return;
} }
let (width, height) = { let (width, height) = {
@ -316,10 +303,8 @@ impl OutputHandler for State {
| Transform::Flipped90 | Transform::Flipped90
| Transform::Flipped270 => (height, width), | Transform::Flipped270 => (height, width),
_ => { _ => {
warn!( warn!("New output {} has unsupported transform",
"New output '{}' has unsupported transform", output_name);
output_name
);
(width, height) (width, height)
} }
} }
@ -327,29 +312,21 @@ impl OutputHandler for State {
let integer_scale_factor = info.scale_factor; let integer_scale_factor = info.scale_factor;
let Some((logical_width, logical_height)) = info.logical_size let Some((logical_width, logical_height)) = info.logical_size else {
else { error!("New output {} has no logical_size, skipping", output_name);
error!( return
"New output '{}' has no logical_size, skipping",
output_name
);
return;
}; };
if !logical_width.is_positive() || !logical_height.is_positive() { if !logical_width.is_positive() || !logical_height.is_positive() {
error!( error!("New output {} has non-positive logical size: {} x {}, \
"New output '{}' has non-positive logical size: {} x {}, skipping", skipping", output_name, logical_width, logical_height);
output_name, logical_width, logical_height return
);
return;
} }
debug!( debug!("New output, name: {}, resolution: {}x{}, integer scale \
"New output, name: {}, resolution: {}x{}, integer scale factor: {}, \ factor: {}, logical size: {}x{}, transform: {:?}",
logical size: {}x{}, transform: {:?}",
output_name, width, height, integer_scale_factor, output_name, width, height, integer_scale_factor,
logical_width, logical_height, info.transform logical_width, logical_height, info.transform);
);
let layer = self.layer_shell.create_layer_surface( let layer = self.layer_shell.create_layer_surface(
qh, qh,
@ -374,7 +351,7 @@ logical size: {}x{}, transform: {:?}",
match Region::new(&self.compositor_state) { match Region::new(&self.compositor_state) {
Ok(region) => surface.set_input_region(Some(region.wl_region())), Ok(region) => surface.set_input_region(Some(region.wl_region())),
Err(error) => error!( Err(error) => error!(
"Failed to create empty input region, on new output '{}': {}", "Failed to create empty input region, on new output {}: {}",
output_name, error output_name, error
) )
}; };
@ -382,16 +359,14 @@ logical size: {}x{}, transform: {:?}",
let mut viewport = None; let mut viewport = None;
if width == logical_width || height == logical_height { if width == logical_width || height == logical_height {
debug!("Output '{}' needs no scaling", output_name); debug!("Output {} needs no scaling", output_name);
} } else if width == logical_width * integer_scale_factor
else if width == logical_width * integer_scale_factor
&& height == logical_height * integer_scale_factor && height == logical_height * integer_scale_factor
{ {
debug!("Output '{}' needs integer scaling", output_name); debug!("Output {} needs integer scaling", output_name);
surface.set_buffer_scale(integer_scale_factor); surface.set_buffer_scale(integer_scale_factor);
} } else {
else { debug!("Output {} needs fractional scaling", output_name);
debug!("Output '{}' needs fractional scaling", output_name);
let new_viewport = self.viewporter.get_viewport(surface, qh, ()); let new_viewport = self.viewporter.get_viewport(surface, qh, ());
new_viewport.set_destination(logical_width, logical_height); new_viewport.set_destination(logical_width, logical_height);
viewport = Some(new_viewport); viewport = Some(new_viewport);
@ -449,12 +424,7 @@ logical size: {}x{}, transform: {:?}",
dmabuf_feedback, dmabuf_feedback,
}); });
if !is_dmabuf_feedback { if !is_dmabuf_feedback {
load_wallpapers( load_wallpapers(self, qh, bg_layer_index, gpu_uploader);
self,
qh,
bg_layer_index,
gpu_uploader,
);
} }
} }
@ -464,35 +434,29 @@ logical size: {}x{}, transform: {:?}",
qh: &QueueHandle<Self>, qh: &QueueHandle<Self>,
output: WlOutput, output: WlOutput,
) { ) {
let Some(info) = self.output_state.info(&output) let Some(info) = self.output_state.info(&output) else {
else {
error!("Updated output has no output info, skipping"); error!("Updated output has no output info, skipping");
return; return
}; };
let Some(output_name) = info.name let Some(output_name) = info.name else {
else {
error!("Updated output has no name, skipping"); error!("Updated output has no name, skipping");
return; return
}; };
let Some((width, height)) = info.modes.iter() let Some((width, height)) = info.modes.iter()
.find(|mode| mode.current) .find(|mode| mode.current)
.map(|mode| mode.dimensions) .map(|mode| mode.dimensions)
else { else {
error!( error!("Updated output {} has no current mode set, skipping",
"Updated output '{}' has no current mode set, skipping", output_name);
output_name return
);
return;
}; };
if !width.is_positive() || !height.is_positive() { if !width.is_positive() || !height.is_positive() {
error!( error!("Updated output {} has non-positive resolution: {} x {}, \
"Updated output '{}' has non-positive resolution: {} x {}, skipping", skipping", output_name, width, height);
output_name, width, height return
);
return;
} }
let (width, height) = { let (width, height) = {
@ -506,10 +470,8 @@ logical size: {}x{}, transform: {:?}",
| Transform::Flipped90 | Transform::Flipped90
| Transform::Flipped270 => (height, width), | Transform::Flipped270 => (height, width),
_ => { _ => {
warn!( warn!("Updated output {} has unsupported transform",
"Updated output '{}' has unsupported transform", output_name);
output_name
);
(width, height) (width, height)
} }
} }
@ -517,67 +479,55 @@ logical size: {}x{}, transform: {:?}",
let integer_scale_factor = info.scale_factor; let integer_scale_factor = info.scale_factor;
let Some((logical_width, logical_height)) = info.logical_size let Some((logical_width, logical_height)) = info.logical_size else {
else { error!("Updated output {} has no logical_size, skipping",
error!( output_name);
"Updated output '{}' has no logical_size, skipping", return
output_name
);
return;
}; };
if !logical_width.is_positive() || !logical_height.is_positive() { if !logical_width.is_positive() || !logical_height.is_positive() {
error!( error!("Updated output {} has non-positive logical size: {} x {}, \
"Updated output '{}' has non-positive logical size: {} x {}, skipping", skipping", output_name, logical_width, logical_height);
output_name, logical_width, logical_height return
);
return;
} }
debug!( debug!("Updated output, name: {}, resolution: {}x{}, integer scale \
"Updated output, name: {}, resolution: {}x{}, integer scale factor: {}, \ factor: {}, logical size: {}x{}, transform: {:?}",
logical size: {}x{}, transform: {:?}",
output_name, width, height, integer_scale_factor, output_name, width, height, integer_scale_factor,
logical_width, logical_height, info.transform logical_width, logical_height, info.transform);
);
let Some(bg_layer) = self.background_layers.iter_mut() let Some(bg_layer) = self.background_layers.iter_mut()
.find(|bg_layers| bg_layers.output_name == output_name) .find(|bg_layers| bg_layers.output_name == output_name)
else { else {
error!( error!("Updated output {} has no background layer, skipping",
"Updated output '{}' has no background layer, skipping", output_name);
output_name return
);
return;
}; };
if bg_layer.width != width || bg_layer.height != height { if bg_layer.width != width || bg_layer.height != height {
warn!( warn!("Handling of output mode or transform changes are not yet \
"Handling of output mode or transform changes are not yet implemented. \ implemented. Restart multibg-sway or expect broken wallpapers \
Restart multibg-sway or expect broken wallpapers or low quality due to scaling" or low quality due to scaling");
);
} }
let surface = bg_layer.layer.wl_surface(); let surface = bg_layer.layer.wl_surface();
if width == logical_width || height == logical_height { if width == logical_width || height == logical_height {
debug!("Output '{}' needs no scaling", output_name); debug!("Output {} needs no scaling", output_name);
surface.set_buffer_scale(1); surface.set_buffer_scale(1);
if let Some(old_viewport) = bg_layer.viewport.take() { if let Some(old_viewport) = bg_layer.viewport.take() {
old_viewport.destroy(); old_viewport.destroy();
}; };
} } else if width == logical_width * integer_scale_factor
else if width == logical_width * integer_scale_factor
&& height == logical_height * integer_scale_factor && height == logical_height * integer_scale_factor
{ {
debug!("Output '{}' needs integer scaling", output_name); debug!("Output {} needs integer scaling", output_name);
surface.set_buffer_scale(integer_scale_factor); surface.set_buffer_scale(integer_scale_factor);
if let Some(old_viewport) = bg_layer.viewport.take() { if let Some(old_viewport) = bg_layer.viewport.take() {
old_viewport.destroy(); old_viewport.destroy();
}; };
} } else {
else { debug!("Output {} needs fractional scaling", output_name);
debug!("Output '{}' needs fractional scaling", output_name);
surface.set_buffer_scale(1); surface.set_buffer_scale(1);
bg_layer.viewport bg_layer.viewport
.get_or_insert_with(|| .get_or_insert_with(||
@ -595,22 +545,17 @@ Restart multibg-sway or expect broken wallpapers or low quality due to scaling"
_qh: &QueueHandle<Self>, _qh: &QueueHandle<Self>,
output: WlOutput, output: WlOutput,
) { ) {
let Some(info) = self.output_state.info(&output) let Some(info) = self.output_state.info(&output) else {
else {
error!("Destroyed output has no output info, skipping"); error!("Destroyed output has no output info, skipping");
return; return
}; };
let Some(output_name) = info.name let Some(output_name) = info.name else {
else {
error!("Destroyed output has no name, skipping"); error!("Destroyed output has no name, skipping");
return; return
}; };
debug!( debug!("Output destroyed: {}", output_name);
"Output destroyed: {}",
output_name,
);
if let Some(bg_layer_index) = self.background_layers.iter() if let Some(bg_layer_index) = self.background_layers.iter()
.position(|bg_layers| bg_layers.output_name == output_name) .position(|bg_layers| bg_layers.output_name == output_name)
@ -631,10 +576,10 @@ Restart multibg-sway or expect broken wallpapers or low quality due to scaling"
); );
drop(removed_bg_layer); drop(removed_bg_layer);
} } else {
else {
error!( error!(
"Ignoring destroyed output with unknown name '{}', known outputs were: {}", "Ignoring destroyed output with unknown name '{}', \
known outputs were: {}",
output_name, output_name,
self.background_layers.iter() self.background_layers.iter()
.map(|bg_layer| bg_layer.output_name.as_str()) .map(|bg_layer| bg_layer.output_name.as_str())
@ -647,10 +592,11 @@ Restart multibg-sway or expect broken wallpapers or low quality due to scaling"
} }
impl ProvidesRegistryState for State { impl ProvidesRegistryState for State {
registry_handlers![OutputState];
fn registry(&mut self) -> &mut RegistryState { fn registry(&mut self) -> &mut RegistryState {
&mut self.registry_state &mut self.registry_state
} }
registry_handlers![OutputState];
} }
impl ShmHandler for State { impl ShmHandler for State {
@ -735,16 +681,12 @@ pub struct BackgroundLayer {
pub dmabuf_feedback: Option<ZwpLinuxDmabufFeedbackV1>, pub dmabuf_feedback: Option<ZwpLinuxDmabufFeedbackV1>,
} }
impl BackgroundLayer impl BackgroundLayer {
{ pub fn draw_workspace_bg(&mut self, workspace_name: &str) {
pub fn draw_workspace_bg(&mut self, workspace_name: &str)
{
if !self.configured { if !self.configured {
error!( error!("Cannot draw wallpaper image on the not yet configured \
"Cannot draw wallpaper image on the not yet configured layer for output: {}", layer for output: {}", self.output_name);
self.output_name return
);
return;
} }
let Some(workspace_bg) = self.workspace_backgrounds.iter() let Some(workspace_bg) = self.workspace_backgrounds.iter()
@ -754,14 +696,15 @@ impl BackgroundLayer
) )
else { else {
error!( error!(
"There is no wallpaper image on output '{}' for workspace '{}', only for: {}", "There is no wallpaper image on output {} for workspace {}, \
only for: {}",
self.output_name, self.output_name,
workspace_name, workspace_name,
self.workspace_backgrounds.iter() self.workspace_backgrounds.iter()
.map(|workspace_bg| workspace_bg.workspace_name.as_str()) .map(|workspace_bg| workspace_bg.workspace_name.as_str())
.collect::<Vec<_>>().join(", ") .collect::<Vec<_>>().join(", ")
); );
return; return
}; };
let wallpaper = &workspace_bg.wallpaper; let wallpaper = &workspace_bg.wallpaper;
@ -794,10 +737,8 @@ impl BackgroundLayer
self.current_wallpaper = Some(Rc::clone(wallpaper)); self.current_wallpaper = Some(Rc::clone(wallpaper));
self.queued_wallpaper = None; self.queued_wallpaper = None;
debug!( debug!("Setting wallpaper on output {} for workspace: {}",
"Setting wallpaper on output '{}' for workspace: {}", self.output_name, workspace_name);
self.output_name, workspace_name
);
} }
} }
@ -850,7 +791,7 @@ impl Memory {
fn dmabuf_params_destroy_eq( fn dmabuf_params_destroy_eq(
&mut self, &mut self,
other_params: &ZwpLinuxBufferParamsV1 other_params: &ZwpLinuxBufferParamsV1,
) -> bool { ) -> bool {
if let Memory::Dmabuf { params: params_option, .. } = self { if let Memory::Dmabuf { params: params_option, .. } = self {
if let Some(params) = params_option { if let Some(params) = params_option {
@ -955,12 +896,7 @@ fn fallback_shm_load_wallpapers(
let bg_layer = &mut state.background_layers[bg_layer_index]; let bg_layer = &mut state.background_layers[bg_layer_index];
bg_layer.dmabuf_feedback = None; bg_layer.dmabuf_feedback = None;
bg_layer.workspace_backgrounds.clear(); bg_layer.workspace_backgrounds.clear();
load_wallpapers( load_wallpapers(state, qh, bg_layer_index, None);
state,
qh,
bg_layer_index,
None,
);
} }
fn load_wallpapers( fn load_wallpapers(
@ -993,7 +929,7 @@ fn load_wallpapers(
// https://github.com/gergo-salyi/multibg-sway/issues/6 // https://github.com/gergo-salyi/multibg-sway/issues/6
(width as usize * 3).next_multiple_of(4) (width as usize * 3).next_multiple_of(4)
}, },
_ => unreachable!() _ => unreachable!(),
}; };
let shm_size = shm_stride * height as usize; let shm_size = shm_stride * height as usize;
let mut workspace_backgrounds = Vec::new(); let mut workspace_backgrounds = Vec::new();
@ -1048,7 +984,7 @@ fn load_wallpapers(
width as usize * 4, width as usize * 4,
wl_shm::Format::Xrgb8888, wl_shm::Format::Xrgb8888,
state.color_transform, state.color_transform,
&mut resizer &mut resizer,
) { ) {
error!("Failed to load wallpaper: {e:#}"); error!("Failed to load wallpaper: {e:#}");
error_count += 1; error_count += 1;
@ -1095,7 +1031,7 @@ fn load_wallpapers(
shm_stride, shm_stride,
state.shm_format, state.shm_format,
state.color_transform, state.color_transform,
&mut resizer &mut resizer,
) { ) {
error!("Failed to load wallpaper: {e:#}"); error!("Failed to load wallpaper: {e:#}");
error_count += 1; error_count += 1;
@ -1108,7 +1044,7 @@ fn load_wallpapers(
shm_stride.try_into().unwrap(), shm_stride.try_into().unwrap(),
state.shm_format, state.shm_format,
(), (),
qh qh,
); );
workspace_backgrounds.push(WorkspaceBackground { workspace_backgrounds.push(WorkspaceBackground {
workspace_name: wallpaper_file.workspace, workspace_name: wallpaper_file.workspace,
@ -1208,12 +1144,7 @@ fn handle_dmabuf_feedback(
debug!("DMA-BUF feedback changed, reloading wallpapers"); debug!("DMA-BUF feedback changed, reloading wallpapers");
bg_layer.workspace_backgrounds.clear(); bg_layer.workspace_backgrounds.clear();
} }
load_wallpapers( load_wallpapers(state, qh, bg_layer_pos, Some(gpu_uploader));
state,
qh,
bg_layer_pos,
Some(gpu_uploader),
);
Ok(()) Ok(())
} }