Use niri_render_elements! for the screenshot UI

1 files changed, 9 insertions, 144 deletions

diff --git a/src/screenshot_ui.rs b/src/screenshot_ui.rs
index b632e3bf..897761a1 100644
--- a/src/screenshot_ui.rs
+++ b/src/screenshot_ui.rs
@@ -10,15 +10,14 @@ use smithay::backend::allocator::Fourcc;
 use smithay::backend::input::{ButtonState, MouseButton};
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
 use smithay::backend::renderer::element::texture::{TextureBuffer, TextureRenderElement};
-use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
-use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, GlesTexture};
-use smithay::backend::renderer::utils::CommitCounter;
+use smithay::backend::renderer::element::Kind;
+use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture};
 use smithay::backend::renderer::ExportMem;
 use smithay::input::keyboard::{Keysym, ModifiersState};
 use smithay::output::{Output, WeakOutput};
-use smithay::utils::{Buffer, Physical, Point, Rectangle, Scale, Size, Transform};
+use smithay::utils::{Physical, Point, Rectangle, Size, Transform};
 
-use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};
+use crate::niri_render_elements;
 use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
 
 const BORDER: i32 = 2;
@@ -49,10 +48,11 @@ pub struct OutputData {
     locations: [Point<i32, Physical>; 8],
 }
 
-#[derive(Debug)]
-pub enum ScreenshotUiRenderElement {
-    Screenshot(PrimaryGpuTextureRenderElement),
-    SolidColor(SolidColorRenderElement),
+niri_render_elements! {
+    ScreenshotUiRenderElement => {
+        Screenshot = PrimaryGpuTextureRenderElement,
+        SolidColor = SolidColorRenderElement,
+    }
 }
 
 impl ScreenshotUi {
@@ -451,138 +451,3 @@ pub fn rect_from_corner_points(
     let y2 = max(a.y, b.y);
     Rectangle::from_extemities((x1, y1), (x2 + scale, y2 + scale))
 }
-
-// Manual RenderElement implementation due to AsGlesFrame requirement.
-impl Element for ScreenshotUiRenderElement {
-    fn id(&self) -> &Id {
-        match self {
-            Self::Screenshot(elem) => elem.id(),
-            Self::SolidColor(elem) => elem.id(),
-        }
-    }
-
-    fn current_commit(&self) -> CommitCounter {
-        match self {
-            Self::Screenshot(elem) => elem.current_commit(),
-            Self::SolidColor(elem) => elem.current_commit(),
-        }
-    }
-
-    fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
-        match self {
-            Self::Screenshot(elem) => elem.geometry(scale),
-            Self::SolidColor(elem) => elem.geometry(scale),
-        }
-    }
-
-    fn transform(&self) -> Transform {
-        match self {
-            Self::Screenshot(elem) => elem.transform(),
-            Self::SolidColor(elem) => elem.transform(),
-        }
-    }
-
-    fn src(&self) -> Rectangle<f64, Buffer> {
-        match self {
-            Self::Screenshot(elem) => elem.src(),
-            Self::SolidColor(elem) => elem.src(),
-        }
-    }
-
-    fn damage_since(
-        &self,
-        scale: Scale<f64>,
-        commit: Option<CommitCounter>,
-    ) -> Vec<Rectangle<i32, Physical>> {
-        match self {
-            Self::Screenshot(elem) => elem.damage_since(scale, commit),
-            Self::SolidColor(elem) => elem.damage_since(scale, commit),
-        }
-    }
-
-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
-        match self {
-            Self::Screenshot(elem) => elem.opaque_regions(scale),
-            Self::SolidColor(elem) => elem.opaque_regions(scale),
-        }
-    }
-
-    fn alpha(&self) -> f32 {
-        match self {
-            Self::Screenshot(elem) => elem.alpha(),
-            Self::SolidColor(elem) => elem.alpha(),
-        }
-    }
-
-    fn kind(&self) -> Kind {
-        match self {
-            Self::Screenshot(elem) => elem.kind(),
-            Self::SolidColor(elem) => elem.kind(),
-        }
-    }
-}
-
-impl RenderElement<GlesRenderer> for ScreenshotUiRenderElement {
-    fn draw(
-        &self,
-        frame: &mut GlesFrame<'_>,
-        src: Rectangle<f64, Buffer>,
-        dst: Rectangle<i32, Physical>,
-        damage: &[Rectangle<i32, Physical>],
-    ) -> Result<(), GlesError> {
-        match self {
-            Self::Screenshot(elem) => {
-                RenderElement::<GlesRenderer>::draw(&elem, frame, src, dst, damage)
-            }
-            Self::SolidColor(elem) => {
-                RenderElement::<GlesRenderer>::draw(&elem, frame, src, dst, damage)
-            }
-        }
-    }
-
-    fn underlying_storage(&self, _renderer: &mut GlesRenderer) -> Option<UnderlyingStorage> {
-        // If scanout for things other than Wayland buffers is implemented, this will need to take
-        // the target GPU into account.
-        None
-    }
-}
-
-impl<'render> RenderElement<TtyRenderer<'render>> for ScreenshotUiRenderElement {
-    fn draw(
-        &self,
-        frame: &mut TtyFrame<'render, '_>,
-        src: Rectangle<f64, Buffer>,
-        dst: Rectangle<i32, Physical>,
-        damage: &[Rectangle<i32, Physical>],
-    ) -> Result<(), TtyRendererError<'render>> {
-        match self {
-            Self::Screenshot(elem) => {
-                RenderElement::<TtyRenderer<'render>>::draw(&elem, frame, src, dst, damage)
-            }
-            Self::SolidColor(elem) => {
-                RenderElement::<TtyRenderer<'render>>::draw(&elem, frame, src, dst, damage)
-            }
-        }
-    }
-
-    fn underlying_storage(
-        &self,
-        _renderer: &mut TtyRenderer<'render>,
-    ) -> Option<UnderlyingStorage> {
-        // If scanout for things other than Wayland buffers is implemented, this will need to take
-        // the target GPU into account.
-        None
-    }
-}
-
-impl From<SolidColorRenderElement> for ScreenshotUiRenderElement {
-    fn from(x: SolidColorRenderElement) -> Self {
-        Self::SolidColor(x)
-    }
-}
-
-impl From<PrimaryGpuTextureRenderElement> for ScreenshotUiRenderElement {
-    fn from(x: PrimaryGpuTextureRenderElement) -> Self {
-        Self::Screenshot(x)
-    }
-}