Fix memory leak and stopped animation when connecting/disconnecting monitor

[kerty0]

1. Memory leak when connecting/disconnecting monitor (happens on KDE Plasma and Hyprland): if I understand it correctly, Compositor sends LayerSurface closed event which removes Wallpaper belonging to closed surface from Daemon.wallpapers, later Compositor sends WL_REGISTRY global_remove which tries to delete Wallpaper belonging to closed output and stop it animation by searching Daemon.wallpapers by output_name, but fails because Wallpaper has already been removed. This leads to not deleted TransitionAnimator and ImageAnimator, which stops Wallpaper from being dropped and starts memory leak in buffer leading to swww-daemon termination.
   Because I don't know right way to handle this I just duplicated code from global_remove event to closed event so both now stop animations.
2. Stop of animation on primary monitor when connecting/disconnecting second one (only on Hyprland): when disconnecting second, monitor Hyprland sends wl_output done event for primary monitor, and when connecting second monitor Hyprland sends sequence of events with done event in the end for both monitors. wl_output done event stops animations so connecting/disconnecting second monitor stops wallpaper animation on first one.
   I don't know right way to handle this either so I just removed stop_animations from wl_output done event.

[LGFae]

I will have to test this manually (might take a little bit), but I am pretty sure solution 2 is wrong because animations will continue to play if you change the output's configuration. Looking at Wallpaper::commit_surface_changes, it appears to return a boolean indicating whether or not we have to stop the animation. I think you can just use it instead. This is what we do in the preferred_scale function:

if wallpaper
       .borrow_mut()
       .commit_surface_changes(self.use_cache)
{
        self.stop_animations(&[wallpaper.clone()]);
}

Solution 1, on the other hand, appears fine.

[kerty0]

I thinking about adding to Daemon something like this:

fn reconfigure_wallpaper(&self, output_name: String) {
    std::thread::Builder::new()
        .name("wallpaper reconfigurator".to_string())
        .stack_size(1 << 14)
        .spawn(move || {
            if let Err(e) = || -> io::Result<()> {
                std::process::Command::new("swaww")
                    .arg("restore")
                    .arg(format!("--outputs={}", output_name))
                    .spawn()?
                    .wait()?;
                Ok(())
            }() {
                warn!("failed to reconfigure wallpaper: {e}");
            }
        })
        .unwrap();
}

And calling it when scaling or resolution of monitor changes so wallpaper always displays correctly. What do you think?

[LGFae]

We are already doing this though. When we receive an output done event we call wallpaper::commit_surface_changes, which calls common::cache::load in a different thread.

There is a problem in that if the daemon is called with the --no-cache flag, then it will never reload the image, even when the output is reconfigured. Maybe that's the problem you would like to solve?