shell: Fix missing titlebars

src/backend/kms/mod.rs

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
+#[cfg(feature = "debug")]
+use crate::backend::render::element::AsGlowRenderer;
 use crate::{
-    backend::render::{element::CosmicElement, workspace_elements, CLEAR_COLOR},
+    backend::render::{workspace_elements, CLEAR_COLOR},
     config::OutputConfig,
     shell::Shell,
     state::{BackendData, ClientState, Common, Data, Fps},
@@ -944,15 +946,6 @@ impl Surface {
             return Ok(());
         }
 
-        self.fps.start();
-        #[cfg(feature = "debug")]
-        if let Some(rd) = self.fps.rd.as_mut() {
-            rd.start_frame_capture(
-                renderer.glow_renderer().egl_context().get_context_handle(),
-                std::ptr::null(),
-            );
-        }
-
         let compositor = self.surface.as_mut().unwrap();
         let (render_node, mut renderer) = match render_node {
             Some((render_node, allocator)) => (
@@ -963,8 +956,17 @@ impl Surface {
             None => (target_node, api.single_renderer(&target_node).unwrap()),
         };
 
+        self.fps.start();
+        #[cfg(feature = "debug")]
+        if let Some(rd) = self.fps.rd.as_mut() {
+            rd.start_frame_capture(
+                renderer.glow_renderer().egl_context().get_context_handle(),
+                std::ptr::null(),
+            );
+        }
+
         let handle = state.shell.workspaces.active(&self.output).handle;
-        let elements: Vec<CosmicElement<GlMultiRenderer<'_, '_>>> = workspace_elements(
+        let elements = workspace_elements(
             Some(&render_node),
             &mut renderer,
             state,
@@ -973,7 +975,10 @@ impl Surface {
             CursorMode::All,
             &mut Some(&mut self.fps),
             false,
-        )?;
+        )
+        .map_err(|err| {
+            anyhow::format_err!("Failed to accumulate elements for rendering: {:?}", err)
+        })?;
         self.fps.elements();
 
         let res = compositor.render_frame::<_, _, Gles2Renderbuffer>(

src/backend/render/mod.rs

@@ -12,7 +12,8 @@ use crate::{
 };
 use crate::{
     shell::{
-        layout::floating::SeatMoveGrabState, CosmicMappedRenderElement, WorkspaceRenderElement,
+        element::window::CosmicWindowRenderElement, layout::floating::SeatMoveGrabState,
+        CosmicMappedRenderElement,
     },
     state::{Common, Fps},
     utils::prelude::SeatExt,
@@ -169,6 +170,7 @@ where
     R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
     <R as Renderer>::TextureId: Clone + 'static,
     CosmicMappedRenderElement<R>: RenderElement<R>,
+    CosmicWindowRenderElement<R>: RenderElement<R>,
     E: From<CursorRenderElement<R>> + From<CosmicMappedRenderElement<R>>,
 {
     #[cfg(feature = "debug")]
@@ -222,7 +224,7 @@ where
     elements
 }
 
-pub fn workspace_elements<R, E>(
+pub fn workspace_elements<R>(
     _gpu: Option<&DrmNode>,
     renderer: &mut R,
     state: &mut Common,
@@ -231,19 +233,18 @@ pub fn workspace_elements<R, E>(
     cursor_mode: CursorMode,
     _fps: &mut Option<&mut Fps>,
     exclude_workspace_overview: bool,
-) -> Result<Vec<E>, OutputNoMode>
+) -> Result<Vec<CosmicElement<R>>, RenderError<R>>
 where
     R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
     <R as Renderer>::TextureId: Clone + 'static,
+    <R as Renderer>::Error: From<Gles2Error>,
     CosmicMappedRenderElement<R>: RenderElement<R>,
-    E: From<CursorRenderElement<R>>
+    CosmicWindowRenderElement<R>: RenderElement<R>,
-        + From<CosmicMappedRenderElement<R>>
-        + From<WorkspaceRenderElement<R>>,
 {
     #[cfg(feature = "debug")]
     puffin::profile_function!();
 
-    let mut elements: Vec<E> = cursor_elements(renderer, state, output, cursor_mode);
+    let mut elements = cursor_elements(renderer, state, output, cursor_mode);
 
     #[cfg(feature = "debug")]
     {
@@ -336,6 +337,7 @@ where
     <R as Renderer>::Error: From<Gles2Error>,
     CosmicElement<R>: RenderElement<R>,
     CosmicMappedRenderElement<R>: RenderElement<R>,
+    CosmicWindowRenderElement<R>: RenderElement<R>,
     Source: Clone,
 {
     let handle = state.shell.workspaces.active(output).handle;
@@ -385,6 +387,7 @@ where
     <R as Renderer>::Error: From<Gles2Error>,
     CosmicElement<R>: RenderElement<R>,
     CosmicMappedRenderElement<R>: RenderElement<R>,
+    CosmicWindowRenderElement<R>: RenderElement<R>,
     Source: Clone,
 {
     #[cfg(feature = "debug")]

src/shell/element/mod.rs

@@ -50,6 +50,7 @@ pub mod stack;
 pub use self::stack::CosmicStack;
 pub mod window;
 pub use self::window::CosmicWindow;
+use self::window::CosmicWindowRenderElement;
 
 #[cfg(feature = "debug")]
 use egui::plot::{Corner, Legend, Plot, PlotPoints, Polygon};
@@ -886,6 +887,7 @@ where
     R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
     CosmicMappedRenderElement<R>: RenderElement<R>,
+    CosmicWindowRenderElement<R>: RenderElement<R>,
 {
     type RenderElement = CosmicMappedRenderElement<R>;
     fn render_elements<C: From<Self::RenderElement>>(

src/shell/element/window.rs

@@ -1,4 +1,8 @@
 use crate::{
+    backend::render::{
+        element::{AsGlowFrame, AsGlowRenderer},
+        GlMultiFrame, GlMultiRenderer,
+    },
     shell::Shell,
     state::State,
     utils::{
@@ -8,7 +12,7 @@ use crate::{
     wayland::handlers::screencopy::ScreencopySessions,
 };
 use calloop::LoopHandle;
-use cosmic::{iced_native::Command, Element};
+use cosmic::iced_native::Command;
 use cosmic_protocols::screencopy::v1::server::zcosmic_screencopy_session_v1::InputType;
 use iced_softbuffer::native::raqote::{DrawOptions, DrawTarget, PathBuilder, SolidSource, Source};
 use smithay::{
@@ -17,8 +21,11 @@ use smithay::{
         renderer::{
             element::{
                 memory::MemoryRenderBufferRenderElement, surface::WaylandSurfaceRenderElement,
-                AsRenderElements,
+                AsRenderElements, Element, Id, RenderElement,
             },
+            glow::GlowRenderer,
+            multigpu::Error as MultiError,
+            utils::CommitCounter,
             ImportAll, ImportMem, Renderer,
         },
     },
@@ -29,8 +36,7 @@ use smithay::{
         Seat,
     },
     output::Output,
-    render_elements,
+    utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size, Transform},
-    utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size},
     wayland::seat::WaylandFocus,
 };
 use std::{
@@ -240,7 +246,7 @@ impl Program for CosmicWindowInternal {
         target.pop_clip();
     }
 
-    fn view(&self) -> Element<'_, Self::Message> {
+    fn view(&self) -> cosmic::Element<'_, Self::Message> {
         cosmic::widget::header_bar()
             .title(self.last_title.lock().unwrap().clone())
             .on_drag(Message::DragStart)
@@ -536,16 +542,162 @@ impl PointerTarget<State> for CosmicWindow {
     }
 }
 
-render_elements! {
+pub enum CosmicWindowRenderElement<R>
-    pub CosmicWindowRenderElement<R> where R: ImportAll + ImportMem;
+where
-    Header=MemoryRenderBufferRenderElement<R>,
+    R: ImportAll + ImportMem + AsGlowRenderer + Renderer,
-    Window=WaylandSurfaceRenderElement<R>,
+    <R as Renderer>::TextureId: 'static,
+{
+    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),
+        }
+    }
+}
+
+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<(), <GlMultiRenderer<'a, 'b> as Renderer>::Error> {
+        match self {
+            CosmicWindowRenderElement::Header(h) => h
+                .draw(frame.glow_frame_mut(), src, dst, damage)
+                .map_err(|err| MultiError::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,
+    R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
+    CosmicWindowRenderElement<R>: RenderElement<R>,
 {
     type RenderElement = CosmicWindowRenderElement<R>;
     fn render_elements<C: From<Self::RenderElement>>(
@@ -568,9 +720,11 @@ where
             )
         });
         if has_ssd {
-            elements.extend(AsRenderElements::<R>::render_elements::<
+            elements.extend(AsRenderElements::<GlowRenderer>::render_elements::<
                 CosmicWindowRenderElement<R>,
-            >(&self.0, renderer, location, scale))
+            >(
+                &self.0, renderer.glow_renderer_mut(), location, scale
+            ))
         }
 
         elements.into_iter().map(C::from).collect()

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

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

src/shell/layout/floating/mod.rs

@@ -15,7 +15,7 @@ use std::collections::HashMap;
 use crate::{
     backend::render::{element::AsGlowRenderer, IndicatorShader},
     shell::{
-        element::{CosmicMapped, CosmicMappedRenderElement},
+        element::{window::CosmicWindowRenderElement, CosmicMapped, CosmicMappedRenderElement},
         grabs::ResizeEdge,
         CosmicSurface,
     },
@@ -354,6 +354,7 @@ impl FloatingLayout {
         R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
         <R as Renderer>::TextureId: 'static,
         CosmicMappedRenderElement<R>: RenderElement<R>,
+        CosmicWindowRenderElement<R>: RenderElement<R>,
     {
         #[cfg(feature = "debug")]
         puffin::profile_function!();

src/shell/layout/tiling/mod.rs

@@ -3,7 +3,7 @@
 use crate::{
     backend::render::{element::AsGlowRenderer, IndicatorShader},
     shell::{
-        element::{CosmicMapped, CosmicMappedRenderElement},
+        element::{window::CosmicWindowRenderElement, CosmicMapped, CosmicMappedRenderElement},
         focus::{
             target::{KeyboardFocusTarget, WindowGroup},
             FocusDirection,
@@ -1311,6 +1311,7 @@ impl TilingLayout {
         R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
         <R as Renderer>::TextureId: 'static,
         CosmicMappedRenderElement<R>: RenderElement<R>,
+        CosmicWindowRenderElement<R>: RenderElement<R>,
     {
         #[cfg(feature = "debug")]
         puffin::profile_function!();

src/shell/mod.rs

@@ -40,7 +40,7 @@ use crate::{
     },
 };
 
-mod element;
+pub mod element;
 pub mod focus;
 pub mod grabs;
 pub mod layout;

src/shell/workspace.rs

@@ -35,7 +35,7 @@ use std::collections::HashMap;
 use tracing::warn;
 
 use super::{
-    element::CosmicMapped,
+    element::{window::CosmicWindowRenderElement, CosmicMapped},
     focus::{FocusStack, FocusStackMut},
     grabs::{ResizeEdge, ResizeGrab},
     CosmicMappedRenderElement, CosmicSurface,
@@ -445,6 +445,7 @@ impl Workspace {
         R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
         <R as Renderer>::TextureId: 'static,
         CosmicMappedRenderElement<R>: RenderElement<R>,
+        CosmicWindowRenderElement<R>: RenderElement<R>,
     {
         #[cfg(feature = "debug")]
         puffin::profile_function!();

src/utils/iced.rs

@@ -230,10 +230,10 @@ impl<P: Program + Send + 'static> IcedElement<P> {
 
     pub fn force_update(&self) {
         let mut internal = self.0.lock().unwrap();
-        internal.update(true);
         for (_buffer, ref mut needs_redraw) in internal.buffers.values_mut() {
             *needs_redraw = true;
         }
+        internal.update(true);
     }
 }
 

src/wayland/handlers/screencopy.rs

@@ -47,7 +47,7 @@ use crate::{
         element::{AsGlowRenderer, CosmicElement},
         render_output, render_workspace, CursorMode, CLEAR_COLOR,
     },
-    shell::{CosmicMappedRenderElement, CosmicSurface},
+    shell::{element::window::CosmicWindowRenderElement, CosmicMappedRenderElement, CosmicSurface},
     state::{BackendData, ClientState, Common, Data, State},
     utils::prelude::OutputExt,
     wayland::protocols::{
@@ -627,6 +627,7 @@ pub fn render_output_to_buffer(
         <R as Renderer>::Error: From<Gles2Error>,
         CosmicElement<R>: RenderElement<R>,
         CosmicMappedRenderElement<R>: RenderElement<R>,
+        CosmicWindowRenderElement<R>: RenderElement<R>,
     {
         let cursor_mode = match session.cursor_mode() {
             ScreencopyCursorMode::Embedded => CursorMode::All,
@@ -756,6 +757,7 @@ pub fn render_workspace_to_buffer(
         <R as Renderer>::Error: From<Gles2Error>,
         CosmicElement<R>: RenderElement<R>,
         CosmicMappedRenderElement<R>: RenderElement<R>,
+        CosmicWindowRenderElement<R>: RenderElement<R>,
     {
         let cursor_mode = match session.cursor_mode() {
             ScreencopyCursorMode::Embedded => CursorMode::All,