shell: Fix render order regarding popups
This commit is contained in:
Victoria Brekenfeld
parent
a308997fd4
commit
c7d4fa5d53
9 changed files with 676 additions and 544 deletions
|
|
@ -14,7 +14,7 @@ use smithay::{
|
|||
renderer::{
|
||||
element::{
|
||||
utils::{CropRenderElement, RelocateRenderElement, RescaleRenderElement},
|
||||
AsRenderElements, Element, RenderElement, UnderlyingStorage,
|
||||
Element, RenderElement, UnderlyingStorage,
|
||||
},
|
||||
gles::element::PixelShaderElement,
|
||||
glow::GlowRenderer,
|
||||
|
|
@ -550,6 +550,206 @@ impl CosmicMapped {
|
|||
debug.take();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn split_render_elements<R, C>(
|
||||
&self,
|
||||
renderer: &mut R,
|
||||
location: smithay::utils::Point<i32, smithay::utils::Physical>,
|
||||
scale: smithay::utils::Scale<f64>,
|
||||
alpha: f32,
|
||||
) -> (Vec<C>, Vec<C>)
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
CosmicMappedRenderElement<R>: RenderElement<R>,
|
||||
C: From<CosmicMappedRenderElement<R>>,
|
||||
{
|
||||
#[cfg(feature = "debug")]
|
||||
let mut debug_elements = if let Some(debug) = self.debug.lock().unwrap().as_mut() {
|
||||
let window = self.active_window();
|
||||
let window_geo = window.geometry();
|
||||
let (min_size, max_size, size) =
|
||||
(window.min_size(), window.max_size(), window.geometry().size);
|
||||
|
||||
let area = Rectangle::<i32, Logical>::from_loc_and_size(
|
||||
location.to_f64().to_logical(scale).to_i32_round(),
|
||||
self.bbox().size,
|
||||
);
|
||||
|
||||
let glow_renderer = renderer.glow_renderer_mut();
|
||||
match debug.render(
|
||||
|ctx| {
|
||||
egui::Area::new("window")
|
||||
.anchor(
|
||||
egui::Align2::RIGHT_TOP,
|
||||
[
|
||||
-window_geo.loc.x as f32 - 10.0,
|
||||
window_geo.loc.y as f32 - 10.0,
|
||||
],
|
||||
)
|
||||
.show(ctx, |ui| {
|
||||
egui::Frame::none()
|
||||
.fill(egui::Color32::BLACK)
|
||||
.rounding(5.0)
|
||||
.inner_margin(10.0)
|
||||
.show(ui, |ui| {
|
||||
ui.heading(window.title());
|
||||
ui.horizontal(|ui| {
|
||||
ui.label("App ID: ");
|
||||
ui.label(window.app_id());
|
||||
});
|
||||
ui.label(match window {
|
||||
CosmicSurface::Wayland(_) => "Protocol: Wayland",
|
||||
CosmicSurface::X11(_) => "Protocol: X11",
|
||||
_ => unreachable!(),
|
||||
});
|
||||
ui.horizontal(|ui| {
|
||||
ui.label("States: ");
|
||||
if window.is_maximized() {
|
||||
ui.label("🗖");
|
||||
}
|
||||
if window.is_fullscreen() {
|
||||
ui.label("⬜");
|
||||
}
|
||||
if window.is_activated() {
|
||||
ui.label("🖱");
|
||||
}
|
||||
if window.is_resizing().is_some() {
|
||||
ui.label("↔");
|
||||
}
|
||||
});
|
||||
|
||||
let plot = Plot::new("Sizes")
|
||||
.legend(Legend::default().position(Corner::RightBottom))
|
||||
.data_aspect(1.0)
|
||||
.view_aspect(1.0)
|
||||
.show_x(false)
|
||||
.show_y(false)
|
||||
.width(200.0)
|
||||
.height(200.0);
|
||||
plot.show(ui, |plot_ui| {
|
||||
let center = if let Some(max_size) = max_size {
|
||||
((max_size.w + 20) / 2, (max_size.h + 20) / 2)
|
||||
} else {
|
||||
(100, 100)
|
||||
};
|
||||
|
||||
if let Some(max_size) = max_size {
|
||||
let max_size_rect =
|
||||
Polygon::new(PlotPoints::new(vec![
|
||||
[10.0, 10.0],
|
||||
[max_size.w as f64 + 10.0, 10.0],
|
||||
[
|
||||
max_size.w as f64 + 10.0,
|
||||
max_size.h as f64 + 10.0,
|
||||
],
|
||||
[10.0, max_size.h as f64 + 10.0],
|
||||
[10.0, 10.0],
|
||||
]));
|
||||
plot_ui.polygon(
|
||||
max_size_rect
|
||||
.name(format!("{}x{}", max_size.w, max_size.h)),
|
||||
);
|
||||
}
|
||||
|
||||
let size_rect = Polygon::new(PlotPoints::new(vec![
|
||||
[
|
||||
(center.0 - size.w / 2) as f64,
|
||||
(center.1 - size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 + size.w / 2) as f64,
|
||||
(center.1 - size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 + size.w / 2) as f64,
|
||||
(center.1 + size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 - size.w / 2) as f64,
|
||||
(center.1 + size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 - size.w / 2) as f64,
|
||||
(center.1 - size.h / 2) as f64,
|
||||
],
|
||||
]));
|
||||
plot_ui.polygon(
|
||||
size_rect.name(format!("{}x{}", size.w, size.h)),
|
||||
);
|
||||
|
||||
if let Some(min_size) = min_size {
|
||||
let min_size_rect =
|
||||
Polygon::new(PlotPoints::new(vec![
|
||||
[
|
||||
(center.0 - min_size.w / 2) as f64,
|
||||
(center.1 - min_size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 + min_size.w / 2) as f64,
|
||||
(center.1 - min_size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 + min_size.w / 2) as f64,
|
||||
(center.1 + min_size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 - min_size.w / 2) as f64,
|
||||
(center.1 + min_size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 - min_size.w / 2) as f64,
|
||||
(center.1 - min_size.h / 2) as f64,
|
||||
],
|
||||
]));
|
||||
plot_ui.polygon(
|
||||
min_size_rect
|
||||
.name(format!("{}x{}", min_size.w, min_size.h)),
|
||||
);
|
||||
}
|
||||
})
|
||||
})
|
||||
});
|
||||
},
|
||||
glow_renderer,
|
||||
area,
|
||||
scale.x,
|
||||
0.8,
|
||||
) {
|
||||
Ok(element) => vec![element.into()],
|
||||
Err(err) => {
|
||||
debug!(?err, "Error rendering debug overlay.");
|
||||
Vec::new()
|
||||
}
|
||||
}
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
#[cfg(not(feature = "debug"))]
|
||||
let debug_elements = Vec::new();
|
||||
|
||||
#[cfg_attr(not(feature = "debug"), allow(unused_mut))]
|
||||
let (window_elements, popup_elements) = match &self.element {
|
||||
CosmicMappedInternal::Stack(s) => s
|
||||
.split_render_elements::<R, CosmicMappedRenderElement<R>>(
|
||||
renderer, location, scale, alpha,
|
||||
),
|
||||
CosmicMappedInternal::Window(w) => w
|
||||
.split_render_elements::<R, CosmicMappedRenderElement<R>>(
|
||||
renderer, location, scale, alpha,
|
||||
),
|
||||
_ => unreachable!(),
|
||||
};
|
||||
|
||||
(
|
||||
debug_elements
|
||||
.into_iter()
|
||||
.map(C::from)
|
||||
.chain(window_elements.into_iter().map(C::from))
|
||||
.collect(),
|
||||
popup_elements.into_iter().map(C::from).collect(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl IsAlive for CosmicMapped {
|
||||
|
|
@ -1026,200 +1226,3 @@ where
|
|||
CosmicMappedRenderElement::Egui(elem)
|
||||
}
|
||||
}
|
||||
|
||||
impl<R> AsRenderElements<R> for CosmicMapped
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
CosmicMappedRenderElement<R>: RenderElement<R>,
|
||||
{
|
||||
type RenderElement = CosmicMappedRenderElement<R>;
|
||||
fn render_elements<C: From<Self::RenderElement>>(
|
||||
&self,
|
||||
renderer: &mut R,
|
||||
location: Point<i32, Physical>,
|
||||
scale: Scale<f64>,
|
||||
alpha: f32,
|
||||
) -> Vec<C> {
|
||||
#[cfg(feature = "debug")]
|
||||
let mut elements = if let Some(debug) = self.debug.lock().unwrap().as_mut() {
|
||||
let window = self.active_window();
|
||||
let window_geo = window.geometry();
|
||||
let (min_size, max_size, size) =
|
||||
(window.min_size(), window.max_size(), window.geometry().size);
|
||||
|
||||
let area = Rectangle::<i32, Logical>::from_loc_and_size(
|
||||
location.to_f64().to_logical(scale).to_i32_round(),
|
||||
self.bbox().size,
|
||||
);
|
||||
|
||||
let glow_renderer = renderer.glow_renderer_mut();
|
||||
match debug.render(
|
||||
|ctx| {
|
||||
egui::Area::new("window")
|
||||
.anchor(
|
||||
egui::Align2::RIGHT_TOP,
|
||||
[
|
||||
-window_geo.loc.x as f32 - 10.0,
|
||||
window_geo.loc.y as f32 - 10.0,
|
||||
],
|
||||
)
|
||||
.show(ctx, |ui| {
|
||||
egui::Frame::none()
|
||||
.fill(egui::Color32::BLACK)
|
||||
.rounding(5.0)
|
||||
.inner_margin(10.0)
|
||||
.show(ui, |ui| {
|
||||
ui.heading(window.title());
|
||||
ui.horizontal(|ui| {
|
||||
ui.label("App ID: ");
|
||||
ui.label(window.app_id());
|
||||
});
|
||||
ui.label(match window {
|
||||
CosmicSurface::Wayland(_) => "Protocol: Wayland",
|
||||
CosmicSurface::X11(_) => "Protocol: X11",
|
||||
_ => unreachable!(),
|
||||
});
|
||||
ui.horizontal(|ui| {
|
||||
ui.label("States: ");
|
||||
if window.is_maximized() {
|
||||
ui.label("🗖");
|
||||
}
|
||||
if window.is_fullscreen() {
|
||||
ui.label("⬜");
|
||||
}
|
||||
if window.is_activated() {
|
||||
ui.label("🖱");
|
||||
}
|
||||
if window.is_resizing().is_some() {
|
||||
ui.label("↔");
|
||||
}
|
||||
});
|
||||
|
||||
let plot = Plot::new("Sizes")
|
||||
.legend(Legend::default().position(Corner::RightBottom))
|
||||
.data_aspect(1.0)
|
||||
.view_aspect(1.0)
|
||||
.show_x(false)
|
||||
.show_y(false)
|
||||
.width(200.0)
|
||||
.height(200.0);
|
||||
plot.show(ui, |plot_ui| {
|
||||
let center = if let Some(max_size) = max_size {
|
||||
((max_size.w + 20) / 2, (max_size.h + 20) / 2)
|
||||
} else {
|
||||
(100, 100)
|
||||
};
|
||||
|
||||
if let Some(max_size) = max_size {
|
||||
let max_size_rect =
|
||||
Polygon::new(PlotPoints::new(vec![
|
||||
[10.0, 10.0],
|
||||
[max_size.w as f64 + 10.0, 10.0],
|
||||
[
|
||||
max_size.w as f64 + 10.0,
|
||||
max_size.h as f64 + 10.0,
|
||||
],
|
||||
[10.0, max_size.h as f64 + 10.0],
|
||||
[10.0, 10.0],
|
||||
]));
|
||||
plot_ui.polygon(
|
||||
max_size_rect
|
||||
.name(format!("{}x{}", max_size.w, max_size.h)),
|
||||
);
|
||||
}
|
||||
|
||||
let size_rect = Polygon::new(PlotPoints::new(vec![
|
||||
[
|
||||
(center.0 - size.w / 2) as f64,
|
||||
(center.1 - size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 + size.w / 2) as f64,
|
||||
(center.1 - size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 + size.w / 2) as f64,
|
||||
(center.1 + size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 - size.w / 2) as f64,
|
||||
(center.1 + size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 - size.w / 2) as f64,
|
||||
(center.1 - size.h / 2) as f64,
|
||||
],
|
||||
]));
|
||||
plot_ui.polygon(
|
||||
size_rect.name(format!("{}x{}", size.w, size.h)),
|
||||
);
|
||||
|
||||
if let Some(min_size) = min_size {
|
||||
let min_size_rect =
|
||||
Polygon::new(PlotPoints::new(vec![
|
||||
[
|
||||
(center.0 - min_size.w / 2) as f64,
|
||||
(center.1 - min_size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 + min_size.w / 2) as f64,
|
||||
(center.1 - min_size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 + min_size.w / 2) as f64,
|
||||
(center.1 + min_size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 - min_size.w / 2) as f64,
|
||||
(center.1 + min_size.h / 2) as f64,
|
||||
],
|
||||
[
|
||||
(center.0 - min_size.w / 2) as f64,
|
||||
(center.1 - min_size.h / 2) as f64,
|
||||
],
|
||||
]));
|
||||
plot_ui.polygon(
|
||||
min_size_rect
|
||||
.name(format!("{}x{}", min_size.w, min_size.h)),
|
||||
);
|
||||
}
|
||||
})
|
||||
})
|
||||
});
|
||||
},
|
||||
glow_renderer,
|
||||
area,
|
||||
scale.x,
|
||||
0.8,
|
||||
) {
|
||||
Ok(element) => vec![element.into()],
|
||||
Err(err) => {
|
||||
debug!(?err, "Error rendering debug overlay.");
|
||||
Vec::new()
|
||||
}
|
||||
}
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
#[cfg(not(feature = "debug"))]
|
||||
let mut elements = Vec::new();
|
||||
|
||||
#[cfg_attr(not(feature = "debug"), allow(unused_mut))]
|
||||
match &self.element {
|
||||
CosmicMappedInternal::Stack(s) => {
|
||||
elements.extend(AsRenderElements::<R>::render_elements::<
|
||||
CosmicMappedRenderElement<R>,
|
||||
>(s, renderer, location, scale, alpha))
|
||||
}
|
||||
CosmicMappedInternal::Window(w) => {
|
||||
elements.extend(AsRenderElements::<R>::render_elements::<
|
||||
CosmicMappedRenderElement<R>,
|
||||
>(w, renderer, location, scale, alpha))
|
||||
}
|
||||
_ => {}
|
||||
};
|
||||
|
||||
elements.into_iter().map(C::from).collect()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ use smithay::{
|
|||
},
|
||||
output::Output,
|
||||
render_elements,
|
||||
utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size},
|
||||
utils::{IsAlive, Logical, Point, Rectangle, Serial, Size},
|
||||
wayland::seat::WaylandFocus,
|
||||
};
|
||||
use std::{
|
||||
|
|
@ -462,6 +462,50 @@ impl CosmicStack {
|
|||
pub(super) fn loop_handle(&self) -> LoopHandle<'static, crate::state::Data> {
|
||||
self.0.loop_handle()
|
||||
}
|
||||
|
||||
pub fn split_render_elements<R, C>(
|
||||
&self,
|
||||
renderer: &mut R,
|
||||
location: smithay::utils::Point<i32, smithay::utils::Physical>,
|
||||
scale: smithay::utils::Scale<f64>,
|
||||
alpha: f32,
|
||||
) -> (Vec<C>, Vec<C>)
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
C: From<CosmicStackRenderElement<R>>,
|
||||
{
|
||||
let stack_loc = location
|
||||
+ self
|
||||
.0
|
||||
.with_program(|p| {
|
||||
p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)]
|
||||
.geometry()
|
||||
.loc
|
||||
})
|
||||
.to_physical_precise_round(scale);
|
||||
let window_loc = location + Point::from((0, (TAB_HEIGHT as f64 * scale.y) as i32));
|
||||
|
||||
let elements = AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(
|
||||
&self.0, renderer, stack_loc, scale, alpha,
|
||||
);
|
||||
|
||||
let (window_elements, popup_elements) = self.0.with_program(|p| {
|
||||
p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)]
|
||||
.split_render_elements::<R, CosmicStackRenderElement<R>>(
|
||||
renderer, window_loc, scale, alpha,
|
||||
)
|
||||
});
|
||||
|
||||
(
|
||||
elements
|
||||
.into_iter()
|
||||
.map(C::from)
|
||||
.chain(window_elements.into_iter().map(C::from))
|
||||
.collect(),
|
||||
popup_elements.into_iter().map(C::from).collect(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
|
|
@ -1061,45 +1105,3 @@ render_elements! {
|
|||
Header = MemoryRenderBufferRenderElement<R>,
|
||||
Window = WaylandSurfaceRenderElement<R>,
|
||||
}
|
||||
|
||||
impl<R> AsRenderElements<R> for CosmicStack
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
{
|
||||
type RenderElement = CosmicStackRenderElement<R>;
|
||||
fn render_elements<C: From<Self::RenderElement>>(
|
||||
&self,
|
||||
renderer: &mut R,
|
||||
location: Point<i32, Physical>,
|
||||
scale: Scale<f64>,
|
||||
alpha: f32,
|
||||
) -> Vec<C> {
|
||||
let stack_loc = location
|
||||
+ self
|
||||
.0
|
||||
.with_program(|p| {
|
||||
p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)]
|
||||
.geometry()
|
||||
.loc
|
||||
})
|
||||
.to_physical_precise_round(scale);
|
||||
let window_loc = location + Point::from((0, (TAB_HEIGHT as f64 * scale.y) as i32));
|
||||
|
||||
let mut elements = AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(
|
||||
&self.0, renderer, stack_loc, scale, alpha,
|
||||
);
|
||||
|
||||
elements.extend(self.0.with_program(|p| {
|
||||
AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(
|
||||
&p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)],
|
||||
renderer,
|
||||
window_loc,
|
||||
scale,
|
||||
alpha,
|
||||
)
|
||||
}));
|
||||
|
||||
elements.into_iter().map(C::from).collect()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,8 +3,9 @@ use std::time::Duration;
|
|||
use smithay::{
|
||||
backend::renderer::{
|
||||
element::{
|
||||
surface::WaylandSurfaceRenderElement, utils::select_dmabuf_feedback, AsRenderElements,
|
||||
RenderElementStates,
|
||||
surface::{render_elements_from_surface_tree, WaylandSurfaceRenderElement},
|
||||
utils::select_dmabuf_feedback,
|
||||
AsRenderElements, RenderElementStates,
|
||||
},
|
||||
ImportAll, Renderer,
|
||||
},
|
||||
|
|
@ -14,7 +15,7 @@ use smithay::{
|
|||
take_presentation_feedback_surface_tree, with_surfaces_surface_tree,
|
||||
OutputPresentationFeedback,
|
||||
},
|
||||
Window,
|
||||
PopupManager, Window,
|
||||
},
|
||||
input::{keyboard::KeyboardTarget, pointer::PointerTarget},
|
||||
output::Output,
|
||||
|
|
@ -591,6 +592,50 @@ impl CosmicSurface {
|
|||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn split_render_elements<R, C>(
|
||||
&self,
|
||||
renderer: &mut R,
|
||||
location: smithay::utils::Point<i32, smithay::utils::Physical>,
|
||||
scale: smithay::utils::Scale<f64>,
|
||||
alpha: f32,
|
||||
) -> (Vec<C>, Vec<C>)
|
||||
where
|
||||
R: Renderer + ImportAll,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
C: From<WaylandSurfaceRenderElement<R>>,
|
||||
{
|
||||
match self {
|
||||
CosmicSurface::Wayland(window) => {
|
||||
let surface = window.toplevel().wl_surface();
|
||||
|
||||
let popup_render_elements = PopupManager::popups_for_surface(surface)
|
||||
.flat_map(|(popup, popup_offset)| {
|
||||
let offset = (window.geometry().loc + popup_offset - popup.geometry().loc)
|
||||
.to_physical_precise_round(scale);
|
||||
|
||||
render_elements_from_surface_tree(
|
||||
renderer,
|
||||
popup.wl_surface(),
|
||||
location + offset,
|
||||
scale,
|
||||
alpha,
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
|
||||
let window_render_elements =
|
||||
render_elements_from_surface_tree(renderer, surface, location, scale, alpha);
|
||||
|
||||
(window_render_elements, popup_render_elements)
|
||||
}
|
||||
CosmicSurface::X11(surface) => (
|
||||
surface.render_elements(renderer, location, scale, alpha),
|
||||
Vec::new(),
|
||||
),
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl KeyboardTarget<crate::state::State> for CosmicSurface {
|
||||
|
|
@ -761,6 +806,15 @@ impl WaylandFocus for CosmicSurface {
|
|||
}
|
||||
}
|
||||
|
||||
impl X11Relatable for CosmicSurface {
|
||||
fn is_window(&self, window: &X11Surface) -> bool {
|
||||
match self {
|
||||
CosmicSurface::X11(surface) => surface == window,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<R> AsRenderElements<R> for CosmicSurface
|
||||
where
|
||||
R: Renderer + ImportAll,
|
||||
|
|
@ -786,12 +840,3 @@ where
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl X11Relatable for CosmicSurface {
|
||||
fn is_window(&self, window: &X11Surface) -> bool {
|
||||
match self {
|
||||
CosmicSurface::X11(surface) => surface == window,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,9 +29,7 @@ use smithay::{
|
|||
},
|
||||
output::Output,
|
||||
render_elements,
|
||||
utils::{
|
||||
Buffer as BufferCoords, IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size,
|
||||
},
|
||||
utils::{Buffer as BufferCoords, IsAlive, Logical, Point, Rectangle, Serial, Size},
|
||||
wayland::seat::WaylandFocus,
|
||||
};
|
||||
use std::{
|
||||
|
|
@ -164,6 +162,50 @@ impl CosmicWindow {
|
|||
pub(super) fn loop_handle(&self) -> LoopHandle<'static, crate::state::Data> {
|
||||
self.0.loop_handle()
|
||||
}
|
||||
|
||||
pub fn split_render_elements<R, C>(
|
||||
&self,
|
||||
renderer: &mut R,
|
||||
location: smithay::utils::Point<i32, smithay::utils::Physical>,
|
||||
scale: smithay::utils::Scale<f64>,
|
||||
alpha: f32,
|
||||
) -> (Vec<C>, Vec<C>)
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
C: From<CosmicWindowRenderElement<R>>,
|
||||
{
|
||||
let has_ssd = self.0.with_program(|p| p.has_ssd(false));
|
||||
|
||||
let window_loc = if has_ssd {
|
||||
location + Point::from((0, (SSD_HEIGHT as f64 * scale.y) as i32))
|
||||
} else {
|
||||
location
|
||||
};
|
||||
|
||||
let (mut window_elements, popup_elements) = self.0.with_program(|p| {
|
||||
p.window
|
||||
.split_render_elements::<R, CosmicWindowRenderElement<R>>(
|
||||
renderer, window_loc, scale, alpha,
|
||||
)
|
||||
});
|
||||
|
||||
if has_ssd {
|
||||
let ssd_loc = location
|
||||
+ self
|
||||
.0
|
||||
.with_program(|p| p.window.geometry().loc)
|
||||
.to_physical_precise_round(scale);
|
||||
window_elements.extend(AsRenderElements::<R>::render_elements::<
|
||||
CosmicWindowRenderElement<R>,
|
||||
>(&self.0, renderer, ssd_loc, scale, alpha))
|
||||
}
|
||||
|
||||
(
|
||||
window_elements.into_iter().map(C::from).collect(),
|
||||
popup_elements.into_iter().map(C::from).collect(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
|
|
@ -555,44 +597,3 @@ render_elements! {
|
|||
Header = MemoryRenderBufferRenderElement<R>,
|
||||
Window = WaylandSurfaceRenderElement<R>,
|
||||
}
|
||||
|
||||
impl<R> AsRenderElements<R> for CosmicWindow
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
{
|
||||
type RenderElement = CosmicWindowRenderElement<R>;
|
||||
fn render_elements<C: From<Self::RenderElement>>(
|
||||
&self,
|
||||
renderer: &mut R,
|
||||
location: Point<i32, Physical>,
|
||||
scale: Scale<f64>,
|
||||
alpha: f32,
|
||||
) -> Vec<C> {
|
||||
let has_ssd = self.0.with_program(|p| p.has_ssd(false));
|
||||
|
||||
let window_loc = if has_ssd {
|
||||
location + Point::from((0, (SSD_HEIGHT as f64 * scale.y) as i32))
|
||||
} else {
|
||||
location
|
||||
};
|
||||
|
||||
let mut elements = self.0.with_program(|p| {
|
||||
AsRenderElements::<R>::render_elements::<CosmicWindowRenderElement<R>>(
|
||||
&p.window, renderer, window_loc, scale, alpha,
|
||||
)
|
||||
});
|
||||
if has_ssd {
|
||||
let ssd_loc = location
|
||||
+ self
|
||||
.0
|
||||
.with_program(|p| p.window.geometry().loc)
|
||||
.to_physical_precise_round(scale);
|
||||
elements.extend(AsRenderElements::<R>::render_elements::<
|
||||
CosmicWindowRenderElement<R>,
|
||||
>(&self.0, renderer, ssd_loc, scale, alpha))
|
||||
}
|
||||
|
||||
elements.into_iter().map(C::from).collect()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,10 +11,7 @@ use crate::{
|
|||
};
|
||||
|
||||
use smithay::{
|
||||
backend::renderer::{
|
||||
element::{AsRenderElements, RenderElement},
|
||||
ImportAll, ImportMem, Renderer,
|
||||
},
|
||||
backend::renderer::{element::RenderElement, ImportAll, ImportMem, Renderer},
|
||||
desktop::space::SpaceElement,
|
||||
input::{
|
||||
pointer::{
|
||||
|
|
@ -60,9 +57,8 @@ impl MoveGrabState {
|
|||
let scale = output.current_scale().fractional_scale().into();
|
||||
let render_location = cursor_at.to_i32_round() - output.geometry().loc + self.window_offset;
|
||||
|
||||
let mut elements: Vec<I> = Vec::new();
|
||||
if self.indicator_thickness > 0 {
|
||||
elements.push(
|
||||
let focus_element = if self.indicator_thickness > 0 {
|
||||
Some(
|
||||
CosmicMappedRenderElement::from(IndicatorShader::focus_element(
|
||||
renderer,
|
||||
self.window.clone(),
|
||||
|
|
@ -71,16 +67,23 @@ impl MoveGrabState {
|
|||
1.0,
|
||||
))
|
||||
.into(),
|
||||
);
|
||||
}
|
||||
elements.extend(AsRenderElements::<R>::render_elements::<I>(
|
||||
&self.window,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let (window_elements, popup_elements) = self.window.split_render_elements::<R, I>(
|
||||
renderer,
|
||||
(render_location - self.window.geometry().loc).to_physical_precise_round(scale),
|
||||
scale,
|
||||
1.0,
|
||||
));
|
||||
elements
|
||||
);
|
||||
|
||||
popup_elements
|
||||
.into_iter()
|
||||
.chain(focus_element)
|
||||
.chain(window_elements)
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn send_frames(
|
||||
|
|
|
|||
|
|
@ -438,7 +438,10 @@ impl FloatingLayout {
|
|||
mut resize_indicator: Option<(ResizeMode, ResizeIndicator)>,
|
||||
indicator_thickness: u8,
|
||||
alpha: f32,
|
||||
) -> Vec<CosmicMappedRenderElement<R>>
|
||||
) -> (
|
||||
Vec<CosmicMappedRenderElement<R>>,
|
||||
Vec<CosmicMappedRenderElement<R>>,
|
||||
)
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
|
|
@ -452,25 +455,49 @@ impl FloatingLayout {
|
|||
let output_scale = output.current_scale().fractional_scale();
|
||||
let output_geo = self.space.output_geometry(output).unwrap();
|
||||
|
||||
let mut window_elements = Vec::new();
|
||||
let mut popup_elements = Vec::new();
|
||||
|
||||
self.space
|
||||
.elements_for_output(output)
|
||||
.rev()
|
||||
.flat_map(|elem| {
|
||||
.for_each(|elem| {
|
||||
let render_location = self.space.element_location(elem).unwrap()
|
||||
- output_geo.loc
|
||||
- elem.geometry().loc;
|
||||
let mut elements = elem.render_elements(
|
||||
let (w_elements, p_elements) = elem.split_render_elements(
|
||||
renderer,
|
||||
render_location.to_physical_precise_round(output_scale),
|
||||
output_scale.into(),
|
||||
alpha,
|
||||
);
|
||||
|
||||
if focused == Some(elem) {
|
||||
let mut indicator_geometry = Rectangle::from_loc_and_size(
|
||||
self.space.element_location(elem).unwrap() - output_geo.loc,
|
||||
elem.geometry().size,
|
||||
);
|
||||
|
||||
if let Some((mode, resize)) = resize_indicator.as_mut() {
|
||||
indicator_geometry.loc -= (18, 18).into();
|
||||
indicator_geometry.size += (36, 36).into();
|
||||
resize.resize(indicator_geometry.size);
|
||||
resize.output_enter(output, output_geo);
|
||||
window_elements.extend(
|
||||
resize
|
||||
.render_elements::<CosmicWindowRenderElement<R>>(
|
||||
renderer,
|
||||
indicator_geometry
|
||||
.loc
|
||||
.to_physical_precise_round(output_scale),
|
||||
output_scale.into(),
|
||||
alpha * mode.alpha().unwrap_or(1.0),
|
||||
)
|
||||
.into_iter()
|
||||
.map(CosmicMappedRenderElement::Window),
|
||||
);
|
||||
}
|
||||
|
||||
if indicator_thickness > 0 {
|
||||
let element = IndicatorShader::focus_element(
|
||||
renderer,
|
||||
|
|
@ -479,31 +506,14 @@ impl FloatingLayout {
|
|||
indicator_thickness,
|
||||
alpha,
|
||||
);
|
||||
elements.insert(0, element.into());
|
||||
}
|
||||
|
||||
if let Some((mode, resize)) = resize_indicator.as_mut() {
|
||||
indicator_geometry.loc -= (18, 18).into();
|
||||
indicator_geometry.size += (36, 36).into();
|
||||
resize.resize(indicator_geometry.size);
|
||||
resize.output_enter(output, output_geo);
|
||||
elements = resize
|
||||
.render_elements::<CosmicWindowRenderElement<R>>(
|
||||
renderer,
|
||||
indicator_geometry
|
||||
.loc
|
||||
.to_physical_precise_round(output_scale),
|
||||
output_scale.into(),
|
||||
alpha * mode.alpha().unwrap_or(1.0),
|
||||
)
|
||||
.into_iter()
|
||||
.map(CosmicMappedRenderElement::Window)
|
||||
.chain(elements.into_iter())
|
||||
.collect();
|
||||
window_elements.push(element.into());
|
||||
}
|
||||
}
|
||||
elements
|
||||
})
|
||||
.collect()
|
||||
|
||||
window_elements.extend(w_elements);
|
||||
popup_elements.extend(p_elements);
|
||||
});
|
||||
|
||||
(window_elements, popup_elements)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1974,7 +1974,13 @@ impl TilingLayout {
|
|||
overview: OverviewMode,
|
||||
resize_indicator: Option<(ResizeMode, ResizeIndicator)>,
|
||||
indicator_thickness: u8,
|
||||
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
|
||||
) -> Result<
|
||||
(
|
||||
Vec<CosmicMappedRenderElement<R>>,
|
||||
Vec<CosmicMappedRenderElement<R>>,
|
||||
),
|
||||
OutputNotMapped,
|
||||
>
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
|
|
@ -2014,7 +2020,8 @@ impl TilingLayout {
|
|||
};
|
||||
let draw_groups = overview.alpha();
|
||||
|
||||
let mut elements = Vec::new();
|
||||
let mut window_elements = Vec::new();
|
||||
let mut popup_elements = Vec::new();
|
||||
|
||||
// all gone windows and fade them out
|
||||
let old_geometries = if let Some(reference_tree) = reference_tree.as_ref() {
|
||||
|
|
@ -2034,14 +2041,16 @@ impl TilingLayout {
|
|||
.unzip();
|
||||
|
||||
// all old windows we want to fade out
|
||||
elements.extend(render_old_tree(
|
||||
let (w_elements, p_elements) = render_old_tree(
|
||||
reference_tree,
|
||||
target_tree,
|
||||
renderer,
|
||||
geometries.clone(),
|
||||
output_scale,
|
||||
percentage,
|
||||
));
|
||||
);
|
||||
window_elements.extend(w_elements);
|
||||
popup_elements.extend(p_elements);
|
||||
|
||||
geometries
|
||||
} else {
|
||||
|
|
@ -2063,7 +2072,7 @@ impl TilingLayout {
|
|||
.unzip();
|
||||
|
||||
// all alive windows
|
||||
elements.extend(render_new_tree(
|
||||
let (w_elements, p_elements) = render_new_tree(
|
||||
target_tree,
|
||||
reference_tree,
|
||||
renderer,
|
||||
|
|
@ -2083,14 +2092,16 @@ impl TilingLayout {
|
|||
indicator_thickness
|
||||
},
|
||||
resize_indicator,
|
||||
));
|
||||
);
|
||||
window_elements.extend(w_elements);
|
||||
popup_elements.extend(p_elements);
|
||||
|
||||
// tiling hints
|
||||
if let Some(group_elements) = group_elements {
|
||||
elements.extend(group_elements);
|
||||
window_elements.extend(group_elements);
|
||||
}
|
||||
|
||||
Ok(elements)
|
||||
Ok((window_elements, popup_elements))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2340,7 +2351,10 @@ fn render_old_tree<R>(
|
|||
geometries: Option<HashMap<NodeId, Rectangle<i32, Logical>>>,
|
||||
output_scale: f64,
|
||||
percentage: f32,
|
||||
) -> Vec<CosmicMappedRenderElement<R>>
|
||||
) -> (
|
||||
Vec<CosmicMappedRenderElement<R>>,
|
||||
Vec<CosmicMappedRenderElement<R>>,
|
||||
)
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
|
|
@ -2348,6 +2362,9 @@ where
|
|||
CosmicWindowRenderElement<R>: RenderElement<R>,
|
||||
CosmicStackRenderElement<R>: RenderElement<R>,
|
||||
{
|
||||
let mut window_elements = Vec::new();
|
||||
let mut popup_elements = Vec::new();
|
||||
|
||||
if let Some(root) = reference_tree.root_node_id() {
|
||||
let geometries = geometries.unwrap_or_default();
|
||||
reference_tree
|
||||
|
|
@ -2374,7 +2391,7 @@ where
|
|||
true
|
||||
}
|
||||
})
|
||||
.flat_map(|(mapped, original_geo, scaled_geo)| {
|
||||
.for_each(|(mapped, original_geo, scaled_geo)| {
|
||||
let (scale, offset) = scaled_geo
|
||||
.map(|adapted_geo| scale_to_center(&original_geo, adapted_geo))
|
||||
.unwrap_or_else(|| (1.0.into(), (0, 0).into()));
|
||||
|
|
@ -2396,15 +2413,16 @@ where
|
|||
.geometry()
|
||||
.loc
|
||||
.to_physical_precise_round(output_scale);
|
||||
AsRenderElements::<R>::render_elements::<CosmicMappedRenderElement<R>>(
|
||||
mapped,
|
||||
renderer,
|
||||
original_location,
|
||||
Scale::from(output_scale),
|
||||
1.0 - percentage,
|
||||
)
|
||||
.into_iter()
|
||||
.flat_map(|element| match element {
|
||||
|
||||
let (w_elements, p_elements) = mapped
|
||||
.split_render_elements::<R, CosmicMappedRenderElement<R>>(
|
||||
renderer,
|
||||
original_location,
|
||||
Scale::from(output_scale),
|
||||
1.0 - percentage,
|
||||
);
|
||||
|
||||
window_elements.extend(w_elements.into_iter().flat_map(|element| match element {
|
||||
CosmicMappedRenderElement::Stack(elem) => {
|
||||
Some(CosmicMappedRenderElement::TiledStack({
|
||||
let cropped = CropRenderElement::from_element(
|
||||
|
|
@ -2448,13 +2466,12 @@ where
|
|||
}))
|
||||
}
|
||||
x => Some(x),
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
}));
|
||||
popup_elements.extend(p_elements);
|
||||
});
|
||||
}
|
||||
|
||||
(window_elements, popup_elements)
|
||||
}
|
||||
|
||||
fn render_new_tree<R>(
|
||||
|
|
@ -2468,7 +2485,10 @@ fn render_new_tree<R>(
|
|||
percentage: f32,
|
||||
indicator_thickness: u8,
|
||||
mut resize_indicator: Option<(ResizeMode, ResizeIndicator)>,
|
||||
) -> Vec<CosmicMappedRenderElement<R>>
|
||||
) -> (
|
||||
Vec<CosmicMappedRenderElement<R>>,
|
||||
Vec<CosmicMappedRenderElement<R>>,
|
||||
)
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
|
|
@ -2491,6 +2511,9 @@ where
|
|||
})
|
||||
.map(|(id, _)| id);
|
||||
|
||||
let mut window_elements = Vec::new();
|
||||
let mut popup_elements = Vec::new();
|
||||
|
||||
let mut group_backdrop = None;
|
||||
let mut indicator = None;
|
||||
let mut resize_elements = None;
|
||||
|
|
@ -2501,10 +2524,10 @@ where
|
|||
if let Some(root) = target_tree.root_node_id() {
|
||||
let old_geometries = old_geometries.unwrap_or_default();
|
||||
let geometries = geometries.unwrap_or_default();
|
||||
let elements: Vec<CosmicMappedRenderElement<R>> = target_tree
|
||||
target_tree
|
||||
.traverse_pre_order_ids(root)
|
||||
.unwrap()
|
||||
.flat_map(|node_id| {
|
||||
.for_each(|node_id| {
|
||||
let data = target_tree.get(&node_id).unwrap().data();
|
||||
let (original_geo, scaled_geo) = (data.geometry(), geometries.get(&node_id));
|
||||
|
||||
|
|
@ -2589,8 +2612,6 @@ where
|
|||
(new_geo, percentage)
|
||||
};
|
||||
|
||||
let mut elements = Vec::new();
|
||||
|
||||
if focused.as_ref() == Some(&node_id) {
|
||||
if indicator_thickness > 0 || data.is_group() {
|
||||
let mut geo = geo.clone();
|
||||
|
|
@ -2668,16 +2689,16 @@ where
|
|||
let original_location = (original_geo.loc - mapped.geometry().loc)
|
||||
.to_physical_precise_round(output_scale);
|
||||
|
||||
elements.extend(
|
||||
AsRenderElements::<R>::render_elements::<CosmicMappedRenderElement<R>>(
|
||||
mapped,
|
||||
let (w_elements, p_elements) = mapped
|
||||
.split_render_elements::<R, CosmicMappedRenderElement<R>>(
|
||||
renderer,
|
||||
original_location,
|
||||
Scale::from(output_scale),
|
||||
alpha,
|
||||
)
|
||||
.into_iter()
|
||||
.flat_map(|element| match element {
|
||||
);
|
||||
|
||||
window_elements.extend(w_elements.into_iter().flat_map(
|
||||
|element| match element {
|
||||
CosmicMappedRenderElement::Stack(elem) => {
|
||||
Some(CosmicMappedRenderElement::TiledStack({
|
||||
let cropped = CropRenderElement::from_element(
|
||||
|
|
@ -2721,24 +2742,22 @@ where
|
|||
}))
|
||||
}
|
||||
x => Some(x),
|
||||
}),
|
||||
);
|
||||
},
|
||||
));
|
||||
popup_elements.extend(p_elements)
|
||||
}
|
||||
});
|
||||
|
||||
elements
|
||||
})
|
||||
.collect();
|
||||
|
||||
resize_elements
|
||||
window_elements = resize_elements
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.chain(indicator.into_iter().map(Into::into))
|
||||
.chain(elements)
|
||||
.chain(window_elements)
|
||||
.chain(group_backdrop.into_iter().map(Into::into))
|
||||
.collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
.collect();
|
||||
}
|
||||
|
||||
(window_elements, popup_elements)
|
||||
}
|
||||
|
||||
fn scale_to_center(
|
||||
|
|
|
|||
|
|
@ -493,7 +493,13 @@ impl Workspace {
|
|||
overview: OverviewMode,
|
||||
resize_indicator: Option<(ResizeMode, ResizeIndicator)>,
|
||||
indicator_thickness: u8,
|
||||
) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped>
|
||||
) -> Result<
|
||||
(
|
||||
Vec<WorkspaceRenderElement<R>>,
|
||||
Vec<WorkspaceRenderElement<R>>,
|
||||
),
|
||||
OutputNotMapped,
|
||||
>
|
||||
where
|
||||
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
|
||||
<R as Renderer>::TextureId: 'static,
|
||||
|
|
@ -505,14 +511,15 @@ impl Workspace {
|
|||
#[cfg(feature = "debug")]
|
||||
puffin::profile_function!();
|
||||
|
||||
let mut render_elements = Vec::new();
|
||||
let mut window_elements = Vec::new();
|
||||
let mut popup_elements = Vec::new();
|
||||
|
||||
let output_scale = output.current_scale().fractional_scale();
|
||||
let layer_map = layer_map_for_output(output);
|
||||
let zone = layer_map.non_exclusive_zone();
|
||||
|
||||
if let Some(fullscreen) = self.fullscreen.get(output) {
|
||||
render_elements.extend(
|
||||
popup_elements.extend(
|
||||
override_redirect_windows
|
||||
.iter()
|
||||
.filter(|or| or.geometry().intersection(output.geometry()).is_some())
|
||||
|
|
@ -529,7 +536,7 @@ impl Workspace {
|
|||
);
|
||||
|
||||
// fullscreen window
|
||||
render_elements.extend(AsRenderElements::<R>::render_elements::<
|
||||
window_elements.extend(AsRenderElements::<R>::render_elements::<
|
||||
WorkspaceRenderElement<R>,
|
||||
>(
|
||||
fullscreen,
|
||||
|
|
@ -540,9 +547,13 @@ impl Workspace {
|
|||
));
|
||||
|
||||
if let Some(xwm) = xwm_state.and_then(|state| state.xwm.as_mut()) {
|
||||
if let Err(err) =
|
||||
xwm.update_stacking_order_upwards(render_elements.iter().rev().map(|e| e.id()))
|
||||
{
|
||||
if let Err(err) = xwm.update_stacking_order_upwards(
|
||||
popup_elements
|
||||
.iter()
|
||||
.rev()
|
||||
.map(|e| e.id())
|
||||
.chain(window_elements.iter().rev().map(|e| e.id())),
|
||||
) {
|
||||
warn!(
|
||||
wm_id = ?xwm.id(),
|
||||
?err,
|
||||
|
|
@ -556,7 +567,7 @@ impl Workspace {
|
|||
// - resizing in tiling
|
||||
|
||||
// OR windows above all
|
||||
render_elements.extend(
|
||||
popup_elements.extend(
|
||||
override_redirect_windows
|
||||
.iter()
|
||||
.filter(|or| or.geometry().intersection(output.geometry()).is_some())
|
||||
|
|
@ -592,40 +603,39 @@ impl Workspace {
|
|||
}
|
||||
OverviewMode::None => 1.0,
|
||||
};
|
||||
render_elements.extend(
|
||||
self.floating_layer
|
||||
.render_output::<R>(
|
||||
renderer,
|
||||
output,
|
||||
focused.as_ref(),
|
||||
resize_indicator.clone(),
|
||||
indicator_thickness,
|
||||
alpha,
|
||||
)
|
||||
.into_iter()
|
||||
.map(WorkspaceRenderElement::from),
|
||||
|
||||
let (w_elements, p_elements) = self.floating_layer.render_output::<R>(
|
||||
renderer,
|
||||
output,
|
||||
focused.as_ref(),
|
||||
resize_indicator.clone(),
|
||||
indicator_thickness,
|
||||
alpha,
|
||||
);
|
||||
popup_elements.extend(p_elements.into_iter().map(WorkspaceRenderElement::from));
|
||||
window_elements.extend(w_elements.into_iter().map(WorkspaceRenderElement::from));
|
||||
|
||||
//tiling surfaces
|
||||
render_elements.extend(
|
||||
self.tiling_layer
|
||||
.render_output::<R>(
|
||||
renderer,
|
||||
output,
|
||||
draw_focus_indicator,
|
||||
layer_map.non_exclusive_zone(),
|
||||
overview.clone(),
|
||||
resize_indicator,
|
||||
indicator_thickness,
|
||||
)?
|
||||
.into_iter()
|
||||
.map(WorkspaceRenderElement::from),
|
||||
);
|
||||
let (w_elements, p_elements) = self.tiling_layer.render_output::<R>(
|
||||
renderer,
|
||||
output,
|
||||
draw_focus_indicator,
|
||||
layer_map.non_exclusive_zone(),
|
||||
overview.clone(),
|
||||
resize_indicator,
|
||||
indicator_thickness,
|
||||
)?;
|
||||
popup_elements.extend(p_elements.into_iter().map(WorkspaceRenderElement::from));
|
||||
window_elements.extend(w_elements.into_iter().map(WorkspaceRenderElement::from));
|
||||
|
||||
if let Some(xwm) = xwm_state.and_then(|state| state.xwm.as_mut()) {
|
||||
if let Err(err) =
|
||||
xwm.update_stacking_order_upwards(render_elements.iter().rev().map(|e| e.id()))
|
||||
{
|
||||
if let Err(err) = xwm.update_stacking_order_upwards(
|
||||
popup_elements
|
||||
.iter()
|
||||
.rev()
|
||||
.map(|e| e.id())
|
||||
.chain(window_elements.iter().rev().map(|e| e.id())),
|
||||
) {
|
||||
warn!(
|
||||
wm_id = ?xwm.id(),
|
||||
?err,
|
||||
|
|
@ -647,7 +657,7 @@ impl Workspace {
|
|||
};
|
||||
|
||||
if let Some(alpha) = alpha {
|
||||
render_elements.push(
|
||||
window_elements.push(
|
||||
Into::<CosmicMappedRenderElement<R>>::into(BackdropShader::element(
|
||||
renderer,
|
||||
self.backdrop_id.clone(),
|
||||
|
|
@ -661,7 +671,7 @@ impl Workspace {
|
|||
}
|
||||
}
|
||||
|
||||
Ok(render_elements)
|
||||
Ok((window_elements, popup_elements))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue