diff --git a/src/backend/kms/mod.rs b/src/backend/kms/mod.rs
index d1051649..3ee0a850 100644
--- a/src/backend/kms/mod.rs
+++ b/src/backend/kms/mod.rs
@@ -972,7 +972,7 @@ fn render_node_for_output(
     let workspace = shell.active_space(output);
     let nodes = workspace
         .get_fullscreen(output)
-        .map(|w| vec![w.clone()])
+        .map(|w| vec![w.surface()])
         .unwrap_or_else(|| workspace.windows().collect::<Vec<_>>())
         .into_iter()
         .flat_map(|w| w.wl_surface().and_then(|s| source_node_for_surface(&s, dh)))
diff --git a/src/input/mod.rs b/src/input/mod.rs
index ad62847c..8928eb98 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -1460,7 +1460,11 @@ impl State {
                 let focus_stack = workspace.focus_stack.get(seat);
                 let focused_window = focus_stack.last();
                 if let Some(window) = focused_window.map(|f| f.active_window()) {
-                    workspace.maximize_toggle(&window, &current_output);
+                    workspace.maximize_toggle(
+                        &window,
+                        &current_output,
+                        self.common.event_loop_handle.clone(),
+                    );
                 }
             }
             Action::Resizing(direction) => self.common.shell.set_resize_mode(
@@ -1624,14 +1628,20 @@ fn sessions_for_output(state: &Common, output: &Output) -> impl Iterator<Item =
         .map(|s| (&**s).clone())
         .chain(
             maybe_fullscreen
-                .and_then(|w| w.user_data().get::<ScreencopySessions>())
-                .map(|sessions| {
-                    sessions
-                        .0
-                        .borrow()
-                        .iter()
-                        .map(|s| (&**s).clone())
-                        .collect::<Vec<_>>()
+                .as_ref()
+                .and_then(|w| {
+                    if let Some(sessions) = w.surface().user_data().get::<ScreencopySessions>() {
+                        Some(
+                            sessions
+                                .0
+                                .borrow()
+                                .iter()
+                                .map(|s| (&**s).clone())
+                                .collect::<Vec<_>>(),
+                        )
+                    } else {
+                        None
+                    }
                 })
                 .into_iter()
                 .flatten(),
diff --git a/src/shell/element/window.rs b/src/shell/element/window.rs
index fb4401eb..0d0174ed 100644
--- a/src/shell/element/window.rs
+++ b/src/shell/element/window.rs
@@ -33,6 +33,7 @@ use smithay::{
         Seat,
     },
     output::Output,
+    reexports::wayland_server::protocol::wl_surface::WlSurface,
     render_elements,
     utils::{Buffer as BufferCoords, IsAlive, Logical, Point, Rectangle, Serial, Size},
     wayland::seat::WaylandFocus,
@@ -45,6 +46,7 @@ use std::{
         Arc, Mutex,
     },
 };
+use wayland_backend::server::ObjectId;
 
 use super::{surface::SSD_HEIGHT, CosmicSurface};
 
@@ -257,7 +259,11 @@ impl Program for CosmicWindowInternal {
                                         .windows()
                                         .find(|(w, _)| w.wl_surface().as_ref() == Some(&surface))
                                         .unwrap();
-                                    workspace.maximize_request(&window, &output)
+                                    workspace.maximize_toggle(
+                                        &window,
+                                        &output,
+                                        data.state.common.event_loop_handle.clone(),
+                                    )
                                 }
                             }
                         });
@@ -698,6 +704,16 @@ impl PointerTarget<State> for CosmicWindow {
     }
 }
 
+impl WaylandFocus for CosmicWindow {
+    fn wl_surface(&self) -> Option<WlSurface> {
+        self.0.with_program(|p| p.window.wl_surface())
+    }
+
+    fn same_client_as(&self, object_id: &ObjectId) -> bool {
+        self.0.with_program(|p| p.window.same_client_as(object_id))
+    }
+}
+
 render_elements! {
     pub CosmicWindowRenderElement<R> where R: ImportAll + ImportMem;
     Header = MemoryRenderBufferRenderElement<R>,
diff --git a/src/shell/focus/mod.rs b/src/shell/focus/mod.rs
index d67ea768..b47f4ed0 100644
--- a/src/shell/focus/mod.rs
+++ b/src/shell/focus/mod.rs
@@ -224,13 +224,13 @@ impl Common {
                                 continue; // Focus is valid,
                             }
                         }
-                        KeyboardFocusTarget::Fullscreen(surface) => {
+                        KeyboardFocusTarget::Fullscreen(window) => {
                             let workspace = state.common.shell.active_space(&output);
                             let focus_stack = workspace.focus_stack.get(&seat);
 
                             if focus_stack
                                 .last()
-                                .map(|m| m.has_active_window(&surface))
+                                .map(|m| m.has_active_window(&window.surface()))
                                 .unwrap_or(false)
                                 && workspace.get_fullscreen(&output).is_some()
                             {
diff --git a/src/shell/focus/target.rs b/src/shell/focus/target.rs
index 2c11a8fa..1dc16b2f 100644
--- a/src/shell/focus/target.rs
+++ b/src/shell/focus/target.rs
@@ -1,7 +1,10 @@
 use std::sync::Weak;
 
 use crate::{
-    shell::{element::CosmicMapped, layout::tiling::ResizeForkTarget, CosmicSurface},
+    shell::{
+        element::{CosmicMapped, CosmicWindow},
+        layout::tiling::ResizeForkTarget,
+    },
     utils::prelude::*,
     wayland::handlers::xdg_shell::popup::get_popup_toplevel,
 };
@@ -29,7 +32,7 @@ use smithay::{
 #[derive(Debug, Clone, PartialEq)]
 pub enum PointerFocusTarget {
     Element(CosmicMapped),
-    Fullscreen(CosmicSurface),
+    Fullscreen(CosmicWindow),
     LayerSurface(LayerSurface),
     Popup(PopupKind),
     OverrideRedirect(X11Surface),
@@ -39,7 +42,7 @@ pub enum PointerFocusTarget {
 #[derive(Debug, Clone, PartialEq)]
 pub enum KeyboardFocusTarget {
     Element(CosmicMapped),
-    Fullscreen(CosmicSurface),
+    Fullscreen(CosmicWindow),
     Group(WindowGroup),
     LayerSurface(LayerSurface),
     Popup(PopupKind),
@@ -551,8 +554,8 @@ impl From<CosmicMapped> for PointerFocusTarget {
     }
 }
 
-impl From<CosmicSurface> for PointerFocusTarget {
-    fn from(s: CosmicSurface) -> Self {
+impl From<CosmicWindow> for PointerFocusTarget {
+    fn from(s: CosmicWindow) -> Self {
         PointerFocusTarget::Fullscreen(s)
     }
 }
@@ -587,8 +590,8 @@ impl From<CosmicMapped> for KeyboardFocusTarget {
     }
 }
 
-impl From<CosmicSurface> for KeyboardFocusTarget {
-    fn from(s: CosmicSurface) -> Self {
+impl From<CosmicWindow> for KeyboardFocusTarget {
+    fn from(s: CosmicWindow) -> Self {
         KeyboardFocusTarget::Fullscreen(s)
     }
 }
diff --git a/src/shell/workspace.rs b/src/shell/workspace.rs
index e6429cc1..b346dcd4 100644
--- a/src/shell/workspace.rs
+++ b/src/shell/workspace.rs
@@ -21,6 +21,7 @@ use crate::{
     xwayland::XWaylandState,
 };
 
+use calloop::LoopHandle;
 use id_tree::Tree;
 use indexmap::IndexSet;
 use keyframe::{ease, functions::EaseInOutCubic};
@@ -60,6 +61,7 @@ use super::{
     element::{
         resize_indicator::ResizeIndicator, stack::CosmicStackRenderElement,
         swap_indicator::SwapIndicator, window::CosmicWindowRenderElement, CosmicMapped,
+        CosmicWindow,
     },
     focus::{
         target::{KeyboardFocusTarget, PointerFocusTarget, WindowGroup},
@@ -87,7 +89,7 @@ pub struct Workspace {
 
 #[derive(Debug, Clone)]
 pub struct FullscreenSurface {
-    pub surface: CosmicSurface,
+    pub window: CosmicWindow,
     pub exclusive: bool,
     original_size: Size<i32, Logical>,
     start_at: Option<Instant>,
@@ -117,7 +119,7 @@ impl FullscreenSurface {
 
 impl IsAlive for FullscreenSurface {
     fn alive(&self) -> bool {
-        self.surface.alive()
+        self.window.alive()
     }
 }
 
@@ -182,7 +184,7 @@ impl Workspace {
                     if let Some(signal) = f.animation_signal.take() {
                         signal.store(true, Ordering::SeqCst);
                         if let Some(client) =
-                            f.surface.wl_surface().as_ref().and_then(Resource::client)
+                            f.window.wl_surface().as_ref().and_then(Resource::client)
                         {
                             clients.push((client.id(), client));
                         }
@@ -198,7 +200,7 @@ impl Workspace {
                     if let Some(signal) = f.animation_signal.take() {
                         signal.store(true, Ordering::SeqCst);
                         if let Some(client) =
-                            f.surface.wl_surface().as_ref().and_then(Resource::client)
+                            f.window.wl_surface().as_ref().and_then(Resource::client)
                         {
                             clients.push((client.id(), client));
                         }
@@ -235,8 +237,8 @@ impl Workspace {
         output: &Output,
         toplevel_info: &mut ToplevelInfoState<State, CosmicSurface>,
     ) {
-        if let Some(dead_output_window) = self.fullscreen.remove(output) {
-            self.unfullscreen_request(&dead_output_window.surface);
+        if let Some(dead_output_fullscreen) = self.fullscreen.remove(output) {
+            self.unfullscreen_request(&dead_output_fullscreen.window.surface());
         }
         self.tiling_layer.unmap_output(output, toplevel_info);
         self.floating_layer.unmap_output(output, toplevel_info);
@@ -337,14 +339,19 @@ impl Workspace {
     pub fn recalculate(&mut self, output: &Output) {
         if let Some(f) = self.fullscreen.get(output) {
             if !f.exclusive {
-                f.surface
+                f.window
                     .set_geometry(layer_map_for_output(output).non_exclusive_zone());
             }
         }
         self.tiling_layer.recalculate(output);
     }
 
-    pub fn maximize_request(&mut self, window: &CosmicSurface, output: &Output) {
+    pub fn maximize_request(
+        &mut self,
+        window: &CosmicSurface,
+        output: &Output,
+        evlh: LoopHandle<'static, crate::state::Data>,
+    ) {
         if self.fullscreen.contains_key(output) {
             return;
         }
@@ -353,10 +360,14 @@ impl Workspace {
 
         window.set_fullscreen(false);
         window.set_maximized(true);
-        self.set_fullscreen(window, output, false)
+        self.set_fullscreen(window, output, false, evlh)
     }
     pub fn unmaximize_request(&mut self, window: &CosmicSurface) -> Option<Size<i32, Logical>> {
-        if self.fullscreen.values().any(|w| &w.surface == window) {
+        if self
+            .fullscreen
+            .values()
+            .any(|f| &f.window.surface() == window)
+        {
             self.unfullscreen_request(window);
             self.floating_layer.unmaximize_request(window)
         } else {
@@ -364,11 +375,16 @@ impl Workspace {
         }
     }
 
-    pub fn fullscreen_request(&mut self, window: &CosmicSurface, output: &Output) {
+    pub fn fullscreen_request(
+        &mut self,
+        window: &CosmicSurface,
+        output: &Output,
+        evlh: LoopHandle<'static, crate::state::Data>,
+    ) {
         if self
             .fullscreen
             .get(output)
-            .map(|w| &w.surface != window)
+            .map(|f| &f.window.surface() != window)
             .unwrap_or(false)
         {
             return;
@@ -380,10 +396,16 @@ impl Workspace {
 
         window.set_maximized(false);
         window.set_fullscreen(true);
-        self.set_fullscreen(window, output, true)
+        self.set_fullscreen(window, output, true, evlh)
     }
 
-    fn set_fullscreen<'a>(&mut self, window: &'a CosmicSurface, output: &Output, exclusive: bool) {
+    fn set_fullscreen<'a>(
+        &mut self,
+        window: &'a CosmicSurface,
+        output: &Output,
+        exclusive: bool,
+        evlh: LoopHandle<'static, crate::state::Data>,
+    ) {
         if let Some(mapped) = self
             .mapped()
             .find(|m| m.windows().any(|(w, _)| &w == window))
@@ -391,11 +413,12 @@ impl Workspace {
             mapped.set_active(window);
         }
 
-        window.set_geometry(if exclusive {
+        let window = CosmicWindow::new(window.clone(), evlh);
+        let geo = if exclusive {
             output.geometry()
         } else {
             layer_map_for_output(output).non_exclusive_zone()
-        });
+        };
         let original_size = window.geometry().size;
         let signal = if let Some(surface) = window.wl_surface() {
             let signal = Arc::new(AtomicBool::new(false));
@@ -409,12 +432,14 @@ impl Workspace {
         } else {
             None
         };
-        window.send_configure();
+        window.set_geometry(geo);
+        window.output_enter(output, Rectangle::from_loc_and_size((0, 0), geo.size));
+        window.surface().send_configure();
 
         self.fullscreen.insert(
             output.clone(),
             FullscreenSurface {
-                surface: window.clone(),
+                window: window.clone(),
                 exclusive,
                 original_size,
                 start_at: Some(Instant::now()),
@@ -428,8 +453,9 @@ impl Workspace {
         if let Some((output, f)) = self
             .fullscreen
             .iter_mut()
-            .find(|(_, w)| &w.surface == window)
+            .find(|(_, f)| &f.window.surface() == window)
         {
+            f.window.output_leave(output);
             window.set_maximized(false);
             window.set_fullscreen(false);
             self.floating_layer.unmaximize_request(window);
@@ -472,13 +498,15 @@ impl Workspace {
 
     pub fn remove_fullscreen(&mut self, output: &Output) {
         if let Some(FullscreenSurface {
-            surface,
+            window,
             ended_at,
             start_at,
             animation_signal,
             ..
         }) = self.fullscreen.get_mut(output)
         {
+            window.output_leave(output);
+            let surface = window.surface();
             surface.set_maximized(false);
             surface.set_fullscreen(false);
             self.floating_layer.unmaximize_request(&surface);
@@ -519,28 +547,33 @@ impl Workspace {
         }
     }
 
-    pub fn maximize_toggle(&mut self, window: &CosmicSurface, output: &Output) {
+    pub fn maximize_toggle(
+        &mut self,
+        window: &CosmicSurface,
+        output: &Output,
+        evlh: LoopHandle<'static, crate::state::Data>,
+    ) {
         if self.fullscreen.contains_key(output) {
             self.unmaximize_request(window);
         } else {
-            self.maximize_request(window, output);
+            self.maximize_request(window, output, evlh);
         }
     }
 
-    pub fn get_fullscreen(&self, output: &Output) -> Option<&CosmicSurface> {
+    pub fn get_fullscreen(&self, output: &Output) -> Option<&CosmicWindow> {
         self.fullscreen
             .get(output)
-            .filter(|w| w.alive() && w.exclusive)
-            .filter(|w| w.ended_at.is_none() && w.start_at.is_none())
-            .map(|w| &w.surface)
+            .filter(|f| f.alive() && f.exclusive)
+            .filter(|f| f.ended_at.is_none() && f.start_at.is_none())
+            .map(|f| &f.window)
     }
 
-    pub fn get_maximized(&self, output: &Output) -> Option<&CosmicSurface> {
+    pub fn get_maximized(&self, output: &Output) -> Option<&CosmicWindow> {
         self.fullscreen
             .get(output)
-            .filter(|w| w.alive() && !w.exclusive)
-            .filter(|w| w.ended_at.is_none() && w.start_at.is_none())
-            .map(|w| &w.surface)
+            .filter(|f| f.alive() && !f.exclusive)
+            .filter(|f| f.ended_at.is_none() && f.start_at.is_none())
+            .map(|f| &f.window)
     }
 
     pub fn resize_request(
@@ -574,7 +607,7 @@ impl Workspace {
             if self
                 .fullscreen
                 .values()
-                .any(|f| f.surface.wl_surface().as_ref() == Some(&toplevel))
+                .any(|f| f.window.surface().wl_surface().as_ref() == Some(&toplevel))
             {
                 return false;
             }
@@ -692,20 +725,20 @@ impl Workspace {
     pub fn is_fullscreen(&self, mapped: &CosmicMapped) -> bool {
         self.fullscreen
             .values()
-            .any(|f| f.exclusive && f.surface == mapped.active_window())
+            .any(|f| f.exclusive && f.window.surface() == mapped.active_window())
     }
 
     pub fn is_maximized(&self, mapped: &CosmicMapped) -> bool {
         self.fullscreen
             .values()
-            .any(|f| !f.exclusive && f.surface == mapped.active_window())
+            .any(|f| !f.exclusive && f.window.surface() == mapped.active_window())
     }
 
     pub fn is_floating(&self, mapped: &CosmicMapped) -> bool {
         !self
             .fullscreen
             .values()
-            .any(|f| f.surface == mapped.active_window())
+            .any(|f| f.window.surface() == mapped.active_window())
             && self.floating_layer.mapped().any(|m| m == mapped)
     }
 
@@ -713,7 +746,7 @@ impl Workspace {
         !self
             .fullscreen
             .values()
-            .any(|f| f.surface == mapped.active_window())
+            .any(|f| f.window.surface() == mapped.active_window())
             && self.tiling_layer.mapped().any(|(_, m, _)| m == mapped)
     }
 
@@ -808,9 +841,9 @@ impl Workspace {
 
         if let Some(fullscreen) = self.fullscreen.get(output) {
             // fullscreen window
-            let bbox = fullscreen.surface.bbox();
+            let bbox = fullscreen.window.bbox();
             let element_geo = Rectangle::from_loc_and_size(
-                self.element_for_surface(&fullscreen.surface)
+                self.element_for_surface(&fullscreen.window.surface())
                     .and_then(|elem| {
                         self.floating_layer
                             .space
@@ -883,18 +916,21 @@ impl Workspace {
                 y: target_geo.size.h as f64 / bbox.size.h as f64,
             };
 
-            window_elements.extend(
-                AsRenderElements::<R>::render_elements::<WaylandSurfaceRenderElement<R>>(
-                    &fullscreen.surface,
+            let (w_elements, p_elements) = fullscreen
+                .window
+                .split_render_elements::<R, CosmicWindowRenderElement<R>>(
                     renderer,
                     render_loc,
                     output_scale.into(),
                     alpha,
-                )
-                .into_iter()
-                .map(|elem| RescaleRenderElement::from_element(elem, render_loc, scale))
-                .map(Into::into),
+                );
+            window_elements.extend(
+                w_elements
+                    .into_iter()
+                    .map(|elem| RescaleRenderElement::from_element(elem, render_loc, scale))
+                    .map(Into::into),
             );
+            popup_elements.extend(p_elements.into_iter().map(Into::into));
         }
 
         if self
@@ -1008,8 +1044,9 @@ where
     R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
 {
-    Fullscreen(RescaleRenderElement<WaylandSurfaceRenderElement<R>>),
-    Wayland(WaylandSurfaceRenderElement<R>),
+    OverrideRedirect(WaylandSurfaceRenderElement<R>),
+    Fullscreen(RescaleRenderElement<CosmicWindowRenderElement<R>>),
+    FullscreenPopup(CosmicWindowRenderElement<R>),
     Window(CosmicMappedRenderElement<R>),
     Backdrop(TextureRenderElement<GlesTexture>),
 }
@@ -1021,8 +1058,9 @@ where
 {
     fn id(&self) -> &smithay::backend::renderer::element::Id {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.id(),
             WorkspaceRenderElement::Fullscreen(elem) => elem.id(),
-            WorkspaceRenderElement::Wayland(elem) => elem.id(),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.id(),
             WorkspaceRenderElement::Window(elem) => elem.id(),
             WorkspaceRenderElement::Backdrop(elem) => elem.id(),
         }
@@ -1030,8 +1068,9 @@ where
 
     fn current_commit(&self) -> smithay::backend::renderer::utils::CommitCounter {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.current_commit(),
             WorkspaceRenderElement::Fullscreen(elem) => elem.current_commit(),
-            WorkspaceRenderElement::Wayland(elem) => elem.current_commit(),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.current_commit(),
             WorkspaceRenderElement::Window(elem) => elem.current_commit(),
             WorkspaceRenderElement::Backdrop(elem) => elem.current_commit(),
         }
@@ -1039,8 +1078,9 @@ where
 
     fn src(&self) -> Rectangle<f64, smithay::utils::Buffer> {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.src(),
             WorkspaceRenderElement::Fullscreen(elem) => elem.src(),
-            WorkspaceRenderElement::Wayland(elem) => elem.src(),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.src(),
             WorkspaceRenderElement::Window(elem) => elem.src(),
             WorkspaceRenderElement::Backdrop(elem) => elem.src(),
         }
@@ -1048,8 +1088,9 @@ where
 
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, smithay::utils::Physical> {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.geometry(scale),
             WorkspaceRenderElement::Fullscreen(elem) => elem.geometry(scale),
-            WorkspaceRenderElement::Wayland(elem) => elem.geometry(scale),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.geometry(scale),
             WorkspaceRenderElement::Window(elem) => elem.geometry(scale),
             WorkspaceRenderElement::Backdrop(elem) => elem.geometry(scale),
         }
@@ -1057,8 +1098,9 @@ where
 
     fn location(&self, scale: Scale<f64>) -> Point<i32, smithay::utils::Physical> {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.location(scale),
             WorkspaceRenderElement::Fullscreen(elem) => elem.location(scale),
-            WorkspaceRenderElement::Wayland(elem) => elem.location(scale),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.location(scale),
             WorkspaceRenderElement::Window(elem) => elem.location(scale),
             WorkspaceRenderElement::Backdrop(elem) => elem.location(scale),
         }
@@ -1066,8 +1108,9 @@ where
 
     fn transform(&self) -> smithay::utils::Transform {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.transform(),
             WorkspaceRenderElement::Fullscreen(elem) => elem.transform(),
-            WorkspaceRenderElement::Wayland(elem) => elem.transform(),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.transform(),
             WorkspaceRenderElement::Window(elem) => elem.transform(),
             WorkspaceRenderElement::Backdrop(elem) => elem.transform(),
         }
@@ -1079,8 +1122,9 @@ where
         commit: Option<smithay::backend::renderer::utils::CommitCounter>,
     ) -> Vec<Rectangle<i32, smithay::utils::Physical>> {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.damage_since(scale, commit),
             WorkspaceRenderElement::Fullscreen(elem) => elem.damage_since(scale, commit),
-            WorkspaceRenderElement::Wayland(elem) => elem.damage_since(scale, commit),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.damage_since(scale, commit),
             WorkspaceRenderElement::Window(elem) => elem.damage_since(scale, commit),
             WorkspaceRenderElement::Backdrop(elem) => elem.damage_since(scale, commit),
         }
@@ -1088,8 +1132,9 @@ where
 
     fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, smithay::utils::Physical>> {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.opaque_regions(scale),
             WorkspaceRenderElement::Fullscreen(elem) => elem.opaque_regions(scale),
-            WorkspaceRenderElement::Wayland(elem) => elem.opaque_regions(scale),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.opaque_regions(scale),
             WorkspaceRenderElement::Window(elem) => elem.opaque_regions(scale),
             WorkspaceRenderElement::Backdrop(elem) => elem.opaque_regions(scale),
         }
@@ -1097,8 +1142,9 @@ where
 
     fn alpha(&self) -> f32 {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.alpha(),
             WorkspaceRenderElement::Fullscreen(elem) => elem.alpha(),
-            WorkspaceRenderElement::Wayland(elem) => elem.alpha(),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.alpha(),
             WorkspaceRenderElement::Window(elem) => elem.alpha(),
             WorkspaceRenderElement::Backdrop(elem) => elem.alpha(),
         }
@@ -1114,8 +1160,9 @@ impl RenderElement<GlowRenderer> for WorkspaceRenderElement<GlowRenderer> {
         damage: &[Rectangle<i32, smithay::utils::Physical>],
     ) -> Result<(), GlesError> {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.draw(frame, src, dst, damage),
             WorkspaceRenderElement::Fullscreen(elem) => elem.draw(frame, src, dst, damage),
-            WorkspaceRenderElement::Wayland(elem) => elem.draw(frame, src, dst, damage),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.draw(frame, src, dst, damage),
             WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
             WorkspaceRenderElement::Backdrop(elem) => {
                 RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
@@ -1128,8 +1175,9 @@ impl RenderElement<GlowRenderer> for WorkspaceRenderElement<GlowRenderer> {
         renderer: &mut GlowRenderer,
     ) -> Option<smithay::backend::renderer::element::UnderlyingStorage> {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.underlying_storage(renderer),
             WorkspaceRenderElement::Fullscreen(elem) => elem.underlying_storage(renderer),
-            WorkspaceRenderElement::Wayland(elem) => elem.underlying_storage(renderer),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.underlying_storage(renderer),
             WorkspaceRenderElement::Window(elem) => elem.underlying_storage(renderer),
             WorkspaceRenderElement::Backdrop(elem) => elem.underlying_storage(renderer),
         }
@@ -1147,8 +1195,9 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>>
         damage: &[Rectangle<i32, smithay::utils::Physical>],
     ) -> Result<(), GlMultiError> {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.draw(frame, src, dst, damage),
             WorkspaceRenderElement::Fullscreen(elem) => elem.draw(frame, src, dst, damage),
-            WorkspaceRenderElement::Wayland(elem) => elem.draw(frame, src, dst, damage),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.draw(frame, src, dst, damage),
             WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
             WorkspaceRenderElement::Backdrop(elem) => {
                 RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage)
@@ -1162,8 +1211,9 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>>
         renderer: &mut GlMultiRenderer<'a, 'b>,
     ) -> Option<smithay::backend::renderer::element::UnderlyingStorage> {
         match self {
+            WorkspaceRenderElement::OverrideRedirect(elem) => elem.underlying_storage(renderer),
             WorkspaceRenderElement::Fullscreen(elem) => elem.underlying_storage(renderer),
-            WorkspaceRenderElement::Wayland(elem) => elem.underlying_storage(renderer),
+            WorkspaceRenderElement::FullscreenPopup(elem) => elem.underlying_storage(renderer),
             WorkspaceRenderElement::Window(elem) => elem.underlying_storage(renderer),
             WorkspaceRenderElement::Backdrop(elem) => {
                 elem.underlying_storage(renderer.glow_renderer_mut())
@@ -1172,17 +1222,28 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>>
     }
 }
 
-impl<R> From<RescaleRenderElement<WaylandSurfaceRenderElement<R>>> for WorkspaceRenderElement<R>
+impl<R> From<RescaleRenderElement<CosmicWindowRenderElement<R>>> for WorkspaceRenderElement<R>
 where
     R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
     <R as Renderer>::TextureId: 'static,
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
-    fn from(elem: RescaleRenderElement<WaylandSurfaceRenderElement<R>>) -> Self {
+    fn from(elem: RescaleRenderElement<CosmicWindowRenderElement<R>>) -> Self {
         WorkspaceRenderElement::Fullscreen(elem)
     }
 }
 
+impl<R> From<CosmicWindowRenderElement<R>> for WorkspaceRenderElement<R>
+where
+    R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
+    <R as Renderer>::TextureId: 'static,
+    CosmicMappedRenderElement<R>: RenderElement<R>,
+{
+    fn from(elem: CosmicWindowRenderElement<R>) -> Self {
+        WorkspaceRenderElement::FullscreenPopup(elem)
+    }
+}
+
 impl<R> From<WaylandSurfaceRenderElement<R>> for WorkspaceRenderElement<R>
 where
     R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
@@ -1190,7 +1251,7 @@ where
     CosmicMappedRenderElement<R>: RenderElement<R>,
 {
     fn from(elem: WaylandSurfaceRenderElement<R>) -> Self {
-        WorkspaceRenderElement::Wayland(elem)
+        WorkspaceRenderElement::OverrideRedirect(elem)
     }
 }
 
diff --git a/src/wayland/handlers/xdg_shell/mod.rs b/src/wayland/handlers/xdg_shell/mod.rs
index 60774d2d..056e3729 100644
--- a/src/wayland/handlers/xdg_shell/mod.rs
+++ b/src/wayland/handlers/xdg_shell/mod.rs
@@ -164,7 +164,7 @@ impl XdgShellHandler for State {
                     .windows()
                     .find(|(w, _)| w.wl_surface().as_ref() == Some(surface.wl_surface()))
                     .unwrap();
-                workspace.maximize_request(&window, &output)
+                workspace.maximize_request(&window, &output, self.common.event_loop_handle.clone())
             }
         }
     }
@@ -206,7 +206,11 @@ impl XdgShellHandler for State {
                     .windows()
                     .find(|(w, _)| w.wl_surface().as_ref() == Some(surface.wl_surface()))
                     .unwrap();
-                workspace.fullscreen_request(&window, &output)
+                workspace.fullscreen_request(
+                    &window,
+                    &output,
+                    self.common.event_loop_handle.clone(),
+                )
             }
         }
     }
diff --git a/src/xwayland.rs b/src/xwayland.rs
index 16b1a486..b43bb488 100644
--- a/src/xwayland.rs
+++ b/src/xwayland.rs
@@ -401,7 +401,11 @@ impl XwmHandler for Data {
         {
             if let Some(workspace) = self.state.common.shell.space_for_mut(&mapped) {
                 let (window, _) = mapped.windows().find(|(w, _)| w == &surface).unwrap();
-                workspace.maximize_request(&window, &output)
+                workspace.maximize_request(
+                    &window,
+                    &output,
+                    self.state.common.event_loop_handle.clone(),
+                )
             }
         }
     }
@@ -436,7 +440,11 @@ impl XwmHandler for Data {
         {
             if let Some(workspace) = self.state.common.shell.space_for_mut(&mapped) {
                 let (window, _) = mapped.windows().find(|(w, _)| w == &surface).unwrap();
-                workspace.fullscreen_request(&window, &output)
+                workspace.fullscreen_request(
+                    &window,
+                    &output,
+                    self.state.common.event_loop_handle.clone(),
+                )
             }
         }
     }