Implement block-out-from window rule, fix alpha on window screenshots

4 files changed, 28 insertions, 8 deletions

diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index bbca41c9..611f138f 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -48,6 +48,7 @@ pub use self::monitor::MonitorRenderElement;
 use self::workspace::{compute_working_area, Column, ColumnWidth, OutputId, Workspace};
 use crate::niri_render_elements;
 use crate::render_helpers::renderer::NiriRenderer;
+use crate::render_helpers::RenderTarget;
 use crate::utils::output_size;
 use crate::window::ResolvedWindowRules;
 
@@ -96,6 +97,7 @@ pub trait LayoutElement {
         location: Point<i32, Logical>,
         scale: Scale<f64>,
         alpha: f32,
+        target: RenderTarget,
     ) -> Vec<LayoutElementRenderElement<R>>;
 
     fn request_size(&self, size: Size<i32, Logical>);
@@ -1858,6 +1860,7 @@ mod tests {
             _location: Point<i32, Logical>,
             _scale: Scale<f64>,
             _alpha: f32,
+            _target: RenderTarget,
         ) -> Vec<LayoutElementRenderElement<R>> {
             vec![]
         }
diff --git a/src/layout/monitor.rs b/src/layout/monitor.rs
index fbea52cd..6e8cb36d 100644
--- a/src/layout/monitor.rs
+++ b/src/layout/monitor.rs
@@ -16,6 +16,7 @@ use super::workspace::{
 use super::{LayoutElement, Options};
 use crate::animation::Animation;
 use crate::render_helpers::renderer::NiriRenderer;
+use crate::render_helpers::RenderTarget;
 use crate::rubber_band::RubberBand;
 use crate::swipe_tracker::SwipeTracker;
 use crate::utils::output_size;
@@ -700,6 +701,7 @@ impl<W: LayoutElement> Monitor<W> {
     pub fn render_elements<R: NiriRenderer>(
         &self,
         renderer: &mut R,
+        target: RenderTarget,
     ) -> Vec<MonitorRenderElement<R>> {
         let _span = tracy_client::span!("Monitor::render_elements");
 
@@ -722,7 +724,7 @@ impl<W: LayoutElement> Monitor<W> {
 
                 let after_idx = after_idx as usize;
                 let after = if after_idx < self.workspaces.len() {
-                    let after = self.workspaces[after_idx].render_elements(renderer);
+                    let after = self.workspaces[after_idx].render_elements(renderer, target);
                     let after = after.into_iter().filter_map(|elem| {
                         Some(RelocateRenderElement::from_element(
                             CropRenderElement::from_element(
@@ -752,7 +754,7 @@ impl<W: LayoutElement> Monitor<W> {
                 };
 
                 let before_idx = before_idx as usize;
-                let before = self.workspaces[before_idx].render_elements(renderer);
+                let before = self.workspaces[before_idx].render_elements(renderer, target);
                 let before = before.into_iter().filter_map(|elem| {
                     Some(RelocateRenderElement::from_element(
                         CropRenderElement::from_element(
@@ -770,7 +772,8 @@ impl<W: LayoutElement> Monitor<W> {
                 before.chain(after.into_iter().flatten()).collect()
             }
             None => {
-                let elements = self.workspaces[self.active_workspace_idx].render_elements(renderer);
+                let elements =
+                    self.workspaces[self.active_workspace_idx].render_elements(renderer, target);
                 elements
                     .into_iter()
                     .filter_map(|elem| {
diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index faa17840..3d2da48c 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -13,6 +13,7 @@ use crate::animation::Animation;
 use crate::niri_render_elements;
 use crate::render_helpers::offscreen::OffscreenRenderElement;
 use crate::render_helpers::renderer::NiriRenderer;
+use crate::render_helpers::RenderTarget;
 
 /// Toplevel window with decorations.
 #[derive(Debug)]
@@ -324,6 +325,7 @@ impl<W: LayoutElement> Tile<W> {
         scale: Scale<f64>,
         view_size: Size<i32, Logical>,
         focus_ring: bool,
+        target: RenderTarget,
     ) -> impl Iterator<Item = TileRenderElement<R>> {
         let alpha = if self.is_fullscreen {
             1.
@@ -333,7 +335,7 @@ impl<W: LayoutElement> Tile<W> {
 
         let rv = self
             .window
-            .render(renderer, location + self.window_loc(), scale, alpha)
+            .render(renderer, location + self.window_loc(), scale, alpha, target)
             .into_iter()
             .map(Into::into);
 
@@ -376,10 +378,12 @@ impl<W: LayoutElement> Tile<W> {
         scale: Scale<f64>,
         view_size: Size<i32, Logical>,
         focus_ring: bool,
+        target: RenderTarget,
     ) -> impl Iterator<Item = TileRenderElement<R>> {
         if let Some(anim) = &self.open_animation {
             let renderer = renderer.as_gles_renderer();
-            let elements = self.render_inner(renderer, location, scale, view_size, focus_ring);
+            let elements =
+                self.render_inner(renderer, location, scale, view_size, focus_ring, target);
             let elements = elements.collect::<Vec<TileRenderElement<_>>>();
 
             let elem = OffscreenRenderElement::new(
@@ -407,7 +411,8 @@ impl<W: LayoutElement> Tile<W> {
         } else {
             self.window().set_offscreen_element_id(None);
 
-            let elements = self.render_inner(renderer, location, scale, view_size, focus_ring);
+            let elements =
+                self.render_inner(renderer, location, scale, view_size, focus_ring, target);
             None.into_iter().chain(Some(elements).into_iter().flatten())
         }
     }
diff --git a/src/layout/workspace.rs b/src/layout/workspace.rs
index 64be3bcc..7ce71c07 100644
--- a/src/layout/workspace.rs
+++ b/src/layout/workspace.rs
@@ -17,6 +17,7 @@ use super::{LayoutElement, Options};
 use crate::animation::Animation;
 use crate::niri_render_elements;
 use crate::render_helpers::renderer::NiriRenderer;
+use crate::render_helpers::RenderTarget;
 use crate::swipe_tracker::SwipeTracker;
 use crate::utils::id::IdCounter;
 use crate::utils::output_size;
@@ -1316,6 +1317,7 @@ impl<W: LayoutElement> Workspace<W> {
     pub fn render_elements<R: NiriRenderer>(
         &self,
         renderer: &mut R,
+        target: RenderTarget,
     ) -> Vec<WorkspaceRenderElement<R>> {
         if self.columns.is_empty() {
             return vec![];
@@ -1338,8 +1340,15 @@ impl<W: LayoutElement> Workspace<W> {
             first = false;
 
             rv.extend(
-                tile.render(renderer, tile_pos, output_scale, self.view_size, focus_ring)
-                    .map(Into::into),
+                tile.render(
+                    renderer,
+                    tile_pos,
+                    output_scale,
+                    self.view_size,
+                    focus_ring,
+                    target,
+                )
+                .map(Into::into),
             );
         }