shell: refactor unnecessary bounds

src/backend/render/mod.rs

@@ -11,7 +11,6 @@ use std::{
 use crate::{
     config::WorkspaceLayout,
     shell::{
-        element::{stack::CosmicStackRenderElement, window::CosmicWindowRenderElement},
         focus::target::WindowGroup,
         layout::{floating::SeatMoveGrabState, tiling::ANIMATION_DURATION},
         CosmicMapped, CosmicMappedRenderElement, WorkspaceRenderElement,
@@ -363,8 +362,6 @@ where
     R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
     <R as Renderer>::TextureId: Clone + 'static,
     CosmicMappedRenderElement<R>: RenderElement<R>,
-    CosmicWindowRenderElement<R>: RenderElement<R>,
-    CosmicStackRenderElement<R>: RenderElement<R>,
     E: From<CursorRenderElement<R>> + From<CosmicMappedRenderElement<R>>,
 {
     #[cfg(feature = "debug")]
@@ -434,8 +431,6 @@ where
     <R as Renderer>::TextureId: Clone + 'static,
     <R as Renderer>::Error: From<GlesError>,
     CosmicMappedRenderElement<R>: RenderElement<R>,
-    CosmicWindowRenderElement<R>: RenderElement<R>,
-    CosmicStackRenderElement<R>: RenderElement<R>,
     WorkspaceRenderElement<R>: RenderElement<R>,
 {
     #[cfg(feature = "debug")]
@@ -642,7 +637,6 @@ where
     <R as Renderer>::TextureId: Clone + 'static,
     <R as Renderer>::Error: From<GlesError>,
     CosmicMappedRenderElement<R>: RenderElement<R>,
-    CosmicWindowRenderElement<R>: RenderElement<R>,
     WorkspaceRenderElement<R>: RenderElement<R>,
 {
     let layer_map = layer_map_for_output(output);
@@ -687,7 +681,6 @@ where
     <R as Renderer>::TextureId: Clone + 'static,
     <R as Renderer>::Error: From<GlesError>,
     CosmicMappedRenderElement<R>: RenderElement<R>,
-    CosmicWindowRenderElement<R>: RenderElement<R>,
     WorkspaceRenderElement<R>: RenderElement<R>,
 {
     let layer_map = layer_map_for_output(output);
@@ -741,8 +734,6 @@ where
     <R as Renderer>::Error: From<GlesError>,
     CosmicElement<R>: RenderElement<R>,
     CosmicMappedRenderElement<R>: RenderElement<R>,
-    CosmicWindowRenderElement<R>: RenderElement<R>,
-    CosmicStackRenderElement<R>: RenderElement<R>,
     WorkspaceRenderElement<R>: RenderElement<R>,
     Source: Clone,
 {
@@ -801,8 +792,6 @@ where
     <R as Renderer>::Error: From<GlesError>,
     CosmicElement<R>: RenderElement<R>,
     CosmicMappedRenderElement<R>: RenderElement<R>,
-    CosmicWindowRenderElement<R>: RenderElement<R>,
-    CosmicStackRenderElement<R>: RenderElement<R>,
     WorkspaceRenderElement<R>: RenderElement<R>,
     Source: Clone,
 {

src/shell/element/mod.rs

@@ -53,7 +53,6 @@ pub mod stack;
 pub use self::stack::CosmicStack;
 pub mod window;
 pub use self::window::CosmicWindow;
-use self::{stack::CosmicStackRenderElement, window::CosmicWindowRenderElement};
 
 #[cfg(feature = "debug")]
 use egui::plot::{Corner, Legend, Plot, PlotPoints, Polygon};
@@ -727,7 +726,7 @@ impl From<CosmicStack> for CosmicMapped {
 
 pub enum CosmicMappedRenderElement<R>
 where
-    R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
+    R: Renderer + ImportAll + ImportMem,
     <R as Renderer>::TextureId: 'static,
 {
     Stack(self::stack::CosmicStackRenderElement<R>),
@@ -749,7 +748,7 @@ where
 
 impl<R> Element for CosmicMappedRenderElement<R>
 where
-    R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
+    R: Renderer + ImportAll + ImportMem,
     <R as Renderer>::TextureId: 'static,
 {
     fn id(&self) -> &smithay::backend::renderer::element::Id {
@@ -1004,8 +1003,6 @@ where
     R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
     CosmicMappedRenderElement<R>: RenderElement<R>,
-    CosmicWindowRenderElement<R>: RenderElement<R>,
-    CosmicStackRenderElement<R>: RenderElement<R>,
 {
     type RenderElement = CosmicMappedRenderElement<R>;
     fn render_elements<C: From<Self::RenderElement>>(

src/shell/element/stack.rs

@@ -1,9 +1,5 @@
 use crate::{
-    backend::render::{
+    shell::{focus::FocusDirection, Shell},
-        element::{AsGlowFrame, AsGlowRenderer},
-        GlMultiError, GlMultiFrame, GlMultiRenderer,
-    },
-    shell::focus::FocusDirection,
     state::State,
     utils::iced::{IcedElement, Program},
     utils::prelude::SeatExt,
@@ -24,10 +20,8 @@ use smithay::{
         renderer::{
             element::{
                 memory::MemoryRenderBufferRenderElement, surface::WaylandSurfaceRenderElement,
-                AsRenderElements, Element, Id, RenderElement,
+                AsRenderElements,
             },
-            glow::GlowRenderer,
-            utils::CommitCounter,
             ImportAll, ImportMem, Renderer,
         },
     },
@@ -38,7 +32,9 @@ use smithay::{
         Seat,
     },
     output::Output,
-    utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size, Transform},
+    render_elements,
+    utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size},
+    wayland::seat::WaylandFocus,
 };
 use std::{
     fmt,
@@ -1057,169 +1053,16 @@ impl PointerTarget<State> for CosmicStack {
     }
 }
 
-pub enum CosmicStackRenderElement<R>
+render_elements! {
-where
+    pub CosmicStackRenderElement<R> where R: ImportAll + ImportMem;
-    R: ImportAll + ImportMem + AsGlowRenderer + Renderer,
+    Header = MemoryRenderBufferRenderElement<R>,
-    <R as Renderer>::TextureId: 'static,
+    Window = WaylandSurfaceRenderElement<R>,
-{
-    Header(MemoryRenderBufferRenderElement<GlowRenderer>),
-    Window(WaylandSurfaceRenderElement<R>),
-}
-
-impl<R> From<WaylandSurfaceRenderElement<R>> for CosmicStackRenderElement<R>
-where
-    R: ImportAll + ImportMem + AsGlowRenderer + Renderer,
-    <R as Renderer>::TextureId: 'static,
-{
-    fn from(elem: WaylandSurfaceRenderElement<R>) -> Self {
-        CosmicStackRenderElement::Window(elem)
-    }
-}
-
-impl<R> From<MemoryRenderBufferRenderElement<GlowRenderer>> for CosmicStackRenderElement<R>
-where
-    R: ImportAll + ImportMem + AsGlowRenderer + Renderer,
-    <R as Renderer>::TextureId: 'static,
-{
-    fn from(elem: MemoryRenderBufferRenderElement<GlowRenderer>) -> Self {
-        CosmicStackRenderElement::Header(elem)
-    }
-}
-
-impl<R> Element for CosmicStackRenderElement<R>
-where
-    R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
-    <R as Renderer>::TextureId: 'static,
-{
-    fn id(&self) -> &Id {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.id(),
-            CosmicStackRenderElement::Window(w) => w.id(),
-        }
-    }
-
-    fn current_commit(&self) -> CommitCounter {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.current_commit(),
-            CosmicStackRenderElement::Window(w) => w.current_commit(),
-        }
-    }
-
-    fn src(&self) -> Rectangle<f64, smithay::utils::Buffer> {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.src(),
-            CosmicStackRenderElement::Window(w) => w.src(),
-        }
-    }
-
-    fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.geometry(scale),
-            CosmicStackRenderElement::Window(w) => w.geometry(scale),
-        }
-    }
-
-    fn location(&self, scale: Scale<f64>) -> Point<i32, Physical> {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.location(scale),
-            CosmicStackRenderElement::Window(w) => w.location(scale),
-        }
-    }
-
-    fn transform(&self) -> Transform {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.transform(),
-            CosmicStackRenderElement::Window(w) => w.transform(),
-        }
-    }
-
-    fn damage_since(
-        &self,
-        scale: Scale<f64>,
-        commit: Option<CommitCounter>,
-    ) -> Vec<Rectangle<i32, Physical>> {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.damage_since(scale, commit),
-            CosmicStackRenderElement::Window(w) => w.damage_since(scale, commit),
-        }
-    }
-
-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.opaque_regions(scale),
-            CosmicStackRenderElement::Window(w) => w.opaque_regions(scale),
-        }
-    }
-
-    fn alpha(&self) -> f32 {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.alpha(),
-            CosmicStackRenderElement::Window(w) => w.alpha(),
-        }
-    }
-}
-
-impl RenderElement<GlowRenderer> for CosmicStackRenderElement<GlowRenderer> {
-    fn draw<'a>(
-        &self,
-        frame: &mut <GlowRenderer as Renderer>::Frame<'a>,
-        src: Rectangle<f64, smithay::utils::Buffer>,
-        dst: Rectangle<i32, Physical>,
-        damage: &[Rectangle<i32, Physical>],
-    ) -> Result<(), <GlowRenderer as Renderer>::Error> {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.draw(frame, src, dst, damage),
-            CosmicStackRenderElement::Window(w) => w.draw(frame, src, dst, damage),
-        }
-    }
-
-    fn underlying_storage(
-        &self,
-        renderer: &mut GlowRenderer,
-    ) -> Option<smithay::backend::renderer::element::UnderlyingStorage> {
-        match self {
-            CosmicStackRenderElement::Header(h) => h.underlying_storage(renderer),
-            CosmicStackRenderElement::Window(w) => w.underlying_storage(renderer),
-        }
-    }
-}
-
-impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>>
-    for CosmicStackRenderElement<GlMultiRenderer<'a, 'b>>
-{
-    fn draw<'c>(
-        &self,
-        frame: &mut GlMultiFrame<'a, 'b, 'c>,
-        src: Rectangle<f64, smithay::utils::Buffer>,
-        dst: Rectangle<i32, Physical>,
-        damage: &[Rectangle<i32, Physical>],
-    ) -> Result<(), GlMultiError> {
-        match self {
-            CosmicStackRenderElement::Header(h) => h
-                .draw(frame.glow_frame_mut(), src, dst, damage)
-                .map_err(|err| GlMultiError::Render(err)),
-            CosmicStackRenderElement::Window(w) => w.draw(frame, src, dst, damage),
-        }
-    }
-
-    fn underlying_storage(
-        &self,
-        renderer: &mut GlMultiRenderer<'a, 'b>,
-    ) -> Option<smithay::backend::renderer::element::UnderlyingStorage> {
-        match self {
-            CosmicStackRenderElement::Header(h) => {
-                h.underlying_storage(renderer.glow_renderer_mut())
-            }
-            CosmicStackRenderElement::Window(w) => w.underlying_storage(renderer),
-        }
-    }
 }
 
 impl<R> AsRenderElements<R> for CosmicStack
 where
-    R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
+    R: Renderer + ImportAll + ImportMem,
     <R as Renderer>::TextureId: 'static,
-    CosmicStackRenderElement<R>: RenderElement<R>,
 {
     type RenderElement = CosmicStackRenderElement<R>;
     fn render_elements<C: From<Self::RenderElement>>(
@@ -1240,14 +1083,9 @@ where
                 .to_physical_precise_round(scale);
         let window_loc = location + Point::from((0, (TAB_HEIGHT as f64 * scale.y) as i32));
 
-        let mut elements =
+        let mut elements = AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(
-            AsRenderElements::<GlowRenderer>::render_elements::<CosmicStackRenderElement<R>>(
+            &self.0, renderer, stack_loc, scale, alpha,
-                &self.0,
+        );
-                renderer.glow_renderer_mut(),
-                stack_loc,
-                scale,
-                alpha,
-            );
 
         elements.extend(self.0.with_program(|p| {
             AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(

src/shell/element/window.rs

@@ -1,8 +1,4 @@
 use crate::{
-    backend::render::{
-        element::{AsGlowFrame, AsGlowRenderer},
-        GlMultiError, GlMultiFrame, GlMultiRenderer,
-    },
     shell::Shell,
     state::State,
     utils::{
@@ -20,10 +16,8 @@ use smithay::{
         renderer::{
             element::{
                 memory::MemoryRenderBufferRenderElement, surface::WaylandSurfaceRenderElement,
-                AsRenderElements, Element, Id, RenderElement,
+                AsRenderElements,
             },
-            glow::GlowRenderer,
-            utils::CommitCounter,
             ImportAll, ImportMem, Renderer,
         },
     },
@@ -34,9 +28,9 @@ use smithay::{
         Seat,
     },
     output::Output,
+    render_elements,
     utils::{
         Buffer as BufferCoords, IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size,
-        Transform,
     },
     wayland::seat::WaylandFocus,
 };
@@ -570,169 +564,16 @@ impl PointerTarget<State> for CosmicWindow {
     }
 }
 
-pub enum CosmicWindowRenderElement<R>
+render_elements! {
-where
+    pub CosmicWindowRenderElement<R> where R: ImportAll + ImportMem;
-    R: ImportAll + ImportMem + AsGlowRenderer + Renderer,
+    Header = MemoryRenderBufferRenderElement<R>,
-    <R as Renderer>::TextureId: 'static,
+    Window = WaylandSurfaceRenderElement<R>,
-{
-    Header(MemoryRenderBufferRenderElement<GlowRenderer>),
-    Window(WaylandSurfaceRenderElement<R>),
-}
-
-impl<R> From<WaylandSurfaceRenderElement<R>> for CosmicWindowRenderElement<R>
-where
-    R: ImportAll + ImportMem + AsGlowRenderer + Renderer,
-    <R as Renderer>::TextureId: 'static,
-{
-    fn from(elem: WaylandSurfaceRenderElement<R>) -> Self {
-        CosmicWindowRenderElement::Window(elem)
-    }
-}
-
-impl<R> From<MemoryRenderBufferRenderElement<GlowRenderer>> for CosmicWindowRenderElement<R>
-where
-    R: ImportAll + ImportMem + AsGlowRenderer + Renderer,
-    <R as Renderer>::TextureId: 'static,
-{
-    fn from(elem: MemoryRenderBufferRenderElement<GlowRenderer>) -> Self {
-        CosmicWindowRenderElement::Header(elem)
-    }
-}
-
-impl<R> Element for CosmicWindowRenderElement<R>
-where
-    R: AsGlowRenderer + Renderer + ImportAll + ImportMem,
-    <R as Renderer>::TextureId: 'static,
-{
-    fn id(&self) -> &Id {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.id(),
-            CosmicWindowRenderElement::Window(w) => w.id(),
-        }
-    }
-
-    fn current_commit(&self) -> CommitCounter {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.current_commit(),
-            CosmicWindowRenderElement::Window(w) => w.current_commit(),
-        }
-    }
-
-    fn src(&self) -> Rectangle<f64, smithay::utils::Buffer> {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.src(),
-            CosmicWindowRenderElement::Window(w) => w.src(),
-        }
-    }
-
-    fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.geometry(scale),
-            CosmicWindowRenderElement::Window(w) => w.geometry(scale),
-        }
-    }
-
-    fn location(&self, scale: Scale<f64>) -> Point<i32, Physical> {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.location(scale),
-            CosmicWindowRenderElement::Window(w) => w.location(scale),
-        }
-    }
-
-    fn transform(&self) -> Transform {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.transform(),
-            CosmicWindowRenderElement::Window(w) => w.transform(),
-        }
-    }
-
-    fn damage_since(
-        &self,
-        scale: Scale<f64>,
-        commit: Option<CommitCounter>,
-    ) -> Vec<Rectangle<i32, Physical>> {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.damage_since(scale, commit),
-            CosmicWindowRenderElement::Window(w) => w.damage_since(scale, commit),
-        }
-    }
-
-    fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.opaque_regions(scale),
-            CosmicWindowRenderElement::Window(w) => w.opaque_regions(scale),
-        }
-    }
-
-    fn alpha(&self) -> f32 {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.alpha(),
-            CosmicWindowRenderElement::Window(w) => w.alpha(),
-        }
-    }
-}
-
-impl RenderElement<GlowRenderer> for CosmicWindowRenderElement<GlowRenderer> {
-    fn draw<'a>(
-        &self,
-        frame: &mut <GlowRenderer as Renderer>::Frame<'a>,
-        src: Rectangle<f64, smithay::utils::Buffer>,
-        dst: Rectangle<i32, Physical>,
-        damage: &[Rectangle<i32, Physical>],
-    ) -> Result<(), <GlowRenderer as Renderer>::Error> {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.draw(frame, src, dst, damage),
-            CosmicWindowRenderElement::Window(w) => w.draw(frame, src, dst, damage),
-        }
-    }
-
-    fn underlying_storage(
-        &self,
-        renderer: &mut GlowRenderer,
-    ) -> Option<smithay::backend::renderer::element::UnderlyingStorage> {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h.underlying_storage(renderer),
-            CosmicWindowRenderElement::Window(w) => w.underlying_storage(renderer),
-        }
-    }
-}
-
-impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>>
-    for CosmicWindowRenderElement<GlMultiRenderer<'a, 'b>>
-{
-    fn draw<'c>(
-        &self,
-        frame: &mut GlMultiFrame<'a, 'b, 'c>,
-        src: Rectangle<f64, smithay::utils::Buffer>,
-        dst: Rectangle<i32, Physical>,
-        damage: &[Rectangle<i32, Physical>],
-    ) -> Result<(), GlMultiError> {
-        match self {
-            CosmicWindowRenderElement::Header(h) => h
-                .draw(frame.glow_frame_mut(), src, dst, damage)
-                .map_err(|err| GlMultiError::Render(err)),
-            CosmicWindowRenderElement::Window(w) => w.draw(frame, src, dst, damage),
-        }
-    }
-
-    fn underlying_storage(
-        &self,
-        renderer: &mut GlMultiRenderer<'a, 'b>,
-    ) -> Option<smithay::backend::renderer::element::UnderlyingStorage> {
-        match self {
-            CosmicWindowRenderElement::Header(h) => {
-                h.underlying_storage(renderer.glow_renderer_mut())
-            }
-            CosmicWindowRenderElement::Window(w) => w.underlying_storage(renderer),
-        }
-    }
 }
 
 impl<R> AsRenderElements<R> for CosmicWindow
 where
-    R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
+    R: Renderer + ImportAll + ImportMem,
     <R as Renderer>::TextureId: 'static,
-    CosmicWindowRenderElement<R>: RenderElement<R>,
 {
     type RenderElement = CosmicWindowRenderElement<R>;
     fn render_elements<C: From<Self::RenderElement>>(
@@ -761,15 +602,9 @@ where
                     .0
                     .with_program(|p| p.window.geometry().loc)
                     .to_physical_precise_round(scale);
-            elements.extend(AsRenderElements::<GlowRenderer>::render_elements::<
+            elements.extend(AsRenderElements::<R>::render_elements::<
                 CosmicWindowRenderElement<R>,
-            >(
+            >(&self.0, renderer, ssd_loc, scale, alpha))
-                &self.0,
-                renderer.glow_renderer_mut(),
-                ssd_loc,
-                scale,
-                alpha,
-            ))
         }
 
         elements.into_iter().map(C::from).collect()

src/shell/layout/floating/grabs/moving.rs

@@ -3,12 +3,9 @@
 use crate::{
     backend::render::{element::AsGlowRenderer, IndicatorShader},
     shell::{
-        element::{
+        element::CosmicMappedRenderElement,
-            stack::CosmicStackRenderElement, window::CosmicWindowRenderElement, CosmicMapped,
-            CosmicMappedRenderElement,
-        },
         focus::target::{KeyboardFocusTarget, PointerFocusTarget},
-        CosmicSurface,
+        CosmicMapped, CosmicSurface,
     },
     utils::prelude::*,
 };
@@ -47,8 +44,6 @@ impl MoveGrabState {
         R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
         <R as Renderer>::TextureId: 'static,
         CosmicMappedRenderElement<R>: RenderElement<R>,
-        CosmicWindowRenderElement<R>: RenderElement<R>,
-        CosmicStackRenderElement<R>: RenderElement<R>,
         I: From<CosmicMappedRenderElement<R>>,
     {
         #[cfg(feature = "debug")]

src/wayland/handlers/screencopy.rs

@@ -48,10 +48,7 @@ use crate::{
         element::{AsGlowRenderer, CosmicElement},
         render_output, render_workspace, CursorMode, CLEAR_COLOR,
     },
-    shell::{
+    shell::{CosmicMappedRenderElement, CosmicSurface, WorkspaceRenderElement},
-        element::{stack::CosmicStackRenderElement, window::CosmicWindowRenderElement},
-        CosmicMappedRenderElement, CosmicSurface, WorkspaceRenderElement,
-    },
     state::{BackendData, ClientState, Common, Data, State},
     utils::prelude::OutputExt,
     wayland::protocols::{
@@ -671,8 +668,6 @@ pub fn render_output_to_buffer(
         <R as Renderer>::Error: From<GlesError>,
         CosmicElement<R>: RenderElement<R>,
         CosmicMappedRenderElement<R>: RenderElement<R>,
-        CosmicWindowRenderElement<R>: RenderElement<R>,
-        CosmicStackRenderElement<R>: RenderElement<R>,
         WorkspaceRenderElement<R>: RenderElement<R>,
     {
         let cursor_mode = match session.cursor_mode() {
@@ -805,8 +800,6 @@ pub fn render_workspace_to_buffer(
         <R as Renderer>::Error: From<GlesError>,
         CosmicElement<R>: RenderElement<R>,
         CosmicMappedRenderElement<R>: RenderElement<R>,
-        CosmicWindowRenderElement<R>: RenderElement<R>,
-        CosmicStackRenderElement<R>: RenderElement<R>,
         WorkspaceRenderElement<R>: RenderElement<R>,
     {
         let cursor_mode = match session.cursor_mode() {