Convert everything to niri_render_elements! {}

4 files changed, 33 insertions, 47 deletions

diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index 2a551b82..111562cd 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -38,14 +38,12 @@ use niri_config::{self, CenterFocusedColumn, Config, SizeChange, Struts};
 use smithay::backend::renderer::element::solid::SolidColorRenderElement;
 use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
 use smithay::backend::renderer::element::AsRenderElements;
-use smithay::backend::renderer::{ImportAll, Renderer};
 use smithay::desktop::space::SpaceElement;
 use smithay::desktop::Window;
 use smithay::output::Output;
 use smithay::reexports::wayland_protocols::xdg::decoration::zv1::server::zxdg_toplevel_decoration_v1;
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::render_elements;
 use smithay::utils::{Logical, Point, Rectangle, Scale, Size, Transform};
 use smithay::wayland::compositor::{send_surface_state, with_states};
 use smithay::wayland::shell::xdg::SurfaceCachedState;
@@ -54,6 +52,8 @@ pub use self::monitor::MonitorRenderElement;
 use self::monitor::{Monitor, WorkspaceSwitch, WorkspaceSwitchGesture};
 use self::workspace::{compute_working_area, Column, ColumnWidth, OutputId, Workspace};
 use crate::animation::Animation;
+use crate::niri_render_elements;
+use crate::render_helpers::NiriRenderer;
 use crate::utils::output_size;
 
 mod focus_ring;
@@ -61,11 +61,11 @@ mod monitor;
 mod tile;
 mod workspace;
 
-render_elements! {
-    #[derive(Debug)]
-    pub LayoutElementRenderElement<R> where R: ImportAll;
-    Wayland = WaylandSurfaceRenderElement<R>,
-    SolidColor = SolidColorRenderElement,
+niri_render_elements! {
+    LayoutElementRenderElement => {
+        Wayland = WaylandSurfaceRenderElement<R>,
+        SolidColor = SolidColorRenderElement,
+    }
 }
 
 pub trait LayoutElement: PartialEq {
@@ -89,14 +89,12 @@ pub trait LayoutElement: PartialEq {
     ///
     /// The element should be rendered in such a way that its visual geometry ends up at the given
     /// location.
-    fn render<R: Renderer + ImportAll>(
+    fn render<R: NiriRenderer>(
         &self,
         renderer: &mut R,
         location: Point<i32, Logical>,
         scale: Scale<f64>,
-    ) -> Vec<LayoutElementRenderElement<R>>
-    where
-        <R as Renderer>::TextureId: 'static;
+    ) -> Vec<LayoutElementRenderElement<R>>;
 
     fn request_size(&self, size: Size<i32, Logical>);
     fn request_fullscreen(&self, size: Size<i32, Logical>);
@@ -227,15 +225,12 @@ impl LayoutElement for Window {
         SpaceElement::is_in_input_region(self, &surace_local)
     }
 
-    fn render<R: Renderer + ImportAll>(
+    fn render<R: NiriRenderer>(
         &self,
         renderer: &mut R,
         location: Point<i32, Logical>,
         scale: Scale<f64>,
-    ) -> Vec<LayoutElementRenderElement<R>>
-    where
-        <R as Renderer>::TextureId: 'static,
-    {
+    ) -> Vec<LayoutElementRenderElement<R>> {
         let buf_pos = location - self.geometry().loc;
         self.render_elements(
             renderer,
@@ -1670,7 +1665,7 @@ mod tests {
             false
         }
 
-        fn render<R: Renderer + ImportAll>(
+        fn render<R: NiriRenderer>(
             &self,
             _renderer: &mut R,
             _location: Point<i32, Logical>,
diff --git a/src/layout/monitor.rs b/src/layout/monitor.rs
index c6cfd615..f63b0c75 100644
--- a/src/layout/monitor.rs
+++ b/src/layout/monitor.rs
@@ -6,7 +6,6 @@ use niri_config::SizeChange;
 use smithay::backend::renderer::element::utils::{
     CropRenderElement, Relocate, RelocateRenderElement,
 };
-use smithay::backend::renderer::{ImportAll, Renderer};
 use smithay::output::Output;
 use smithay::utils::{Logical, Point, Rectangle, Scale};
 
@@ -15,6 +14,7 @@ use super::workspace::{
 };
 use super::{LayoutElement, Options};
 use crate::animation::Animation;
+use crate::render_helpers::NiriRenderer;
 use crate::utils::output_size;
 
 #[derive(Debug)]
@@ -578,13 +578,10 @@ impl<W: LayoutElement> Monitor<W> {
         ws.render_above_top_layer()
     }
 
-    pub fn render_elements<R: Renderer + ImportAll>(
+    pub fn render_elements<R: NiriRenderer>(
         &self,
         renderer: &mut R,
-    ) -> Vec<MonitorRenderElement<R>>
-    where
-        <R as Renderer>::TextureId: 'static,
-    {
+    ) -> Vec<MonitorRenderElement<R>> {
         let _span = tracy_client::span!("Monitor::render_elements");
 
         let output_scale = Scale::from(self.output.current_scale().fractional_scale());
diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index 99c4876b..e4f255b8 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -5,12 +5,12 @@ use std::time::Duration;
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
 use smithay::backend::renderer::element::utils::{Relocate, RelocateRenderElement};
 use smithay::backend::renderer::element::Kind;
-use smithay::backend::renderer::{ImportAll, Renderer};
-use smithay::render_elements;
 use smithay::utils::{Logical, Point, Rectangle, Scale, Size};
 
 use super::focus_ring::FocusRing;
 use super::{LayoutElement, LayoutElementRenderElement, Options};
+use crate::niri_render_elements;
+use crate::render_helpers::NiriRenderer;
 
 /// Toplevel window with decorations.
 #[derive(Debug)]
@@ -37,11 +37,11 @@ pub struct Tile<W: LayoutElement> {
     options: Rc<Options>,
 }
 
-render_elements! {
-    #[derive(Debug)]
-    pub TileRenderElement<R> where R: ImportAll;
-    LayoutElement = LayoutElementRenderElement<R>,
-    SolidColor = RelocateRenderElement<SolidColorRenderElement>,
+niri_render_elements! {
+    TileRenderElement => {
+        LayoutElement = LayoutElementRenderElement<R>,
+        SolidColor = RelocateRenderElement<SolidColorRenderElement>,
+    }
 }
 
 impl<W: LayoutElement> Tile<W> {
@@ -239,15 +239,12 @@ impl<W: LayoutElement> Tile<W> {
         self.effective_border_width().is_some() || self.window.has_ssd()
     }
 
-    pub fn render<R: Renderer + ImportAll>(
+    pub fn render<R: NiriRenderer>(
         &self,
         renderer: &mut R,
         location: Point<i32, Logical>,
         scale: Scale<f64>,
-    ) -> impl Iterator<Item = TileRenderElement<R>>
-    where
-        <R as Renderer>::TextureId: 'static,
-    {
+    ) -> impl Iterator<Item = TileRenderElement<R>> {
         let window_pos = location + self.window_loc();
         let rv = self
             .window
diff --git a/src/layout/workspace.rs b/src/layout/workspace.rs
index c3c3cc75..fbae0064 100644
--- a/src/layout/workspace.rs
+++ b/src/layout/workspace.rs
@@ -4,18 +4,18 @@ use std::rc::Rc;
 use std::time::Duration;
 
 use niri_config::{CenterFocusedColumn, PresetWidth, SizeChange, Struts};
-use smithay::backend::renderer::{ImportAll, Renderer};
 use smithay::desktop::space::SpaceElement;
 use smithay::desktop::{layer_map_for_output, Window};
 use smithay::output::Output;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::render_elements;
 use smithay::utils::{Logical, Point, Rectangle, Scale, Size};
 
 use super::focus_ring::{FocusRing, FocusRingRenderElement};
 use super::tile::{Tile, TileRenderElement};
 use super::{LayoutElement, Options};
 use crate::animation::Animation;
+use crate::niri_render_elements;
+use crate::render_helpers::NiriRenderer;
 use crate::utils::output_size;
 
 #[derive(Debug)]
@@ -77,11 +77,11 @@ pub struct Workspace<W: LayoutElement> {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct OutputId(String);
 
-render_elements! {
-    #[derive(Debug)]
-    pub WorkspaceRenderElement<R> where R: ImportAll;
-    Tile = TileRenderElement<R>,
-    FocusRing = FocusRingRenderElement,
+niri_render_elements! {
+    WorkspaceRenderElement => {
+        Tile = TileRenderElement<R>,
+        FocusRing = FocusRingRenderElement,
+    }
 }
 
 /// Width of a column.
@@ -1068,13 +1068,10 @@ impl<W: LayoutElement> Workspace<W> {
         self.columns[self.active_column_idx].is_fullscreen
     }
 
-    pub fn render_elements<R: Renderer + ImportAll>(
+    pub fn render_elements<R: NiriRenderer>(
         &self,
         renderer: &mut R,
-    ) -> Vec<WorkspaceRenderElement<R>>
-    where
-        <R as Renderer>::TextureId: 'static,
-    {
+    ) -> Vec<WorkspaceRenderElement<R>> {
         if self.columns.is_empty() {
             return vec![];
         }