leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

render: Use render_input_order

Browse source
This commit is contained in:
Victoria Brekenfeld 2024-09-27 23:41:58 +02:00 • committed by Victoria Brekenfeld
parent 140d870e7b
commit 51c8588f89
10 changed files with 1154 additions and 763 deletions
Download patch file Download diff file Expand all files Collapse all files

73
src/shell/element/mod.rs
View file

@ -1,8 +1,5 @@
use crate::{
backend::render::{
element::{AsGlowRenderer, FromGlesError},
SplitRenderElements,
},
backend::render::element::{AsGlowRenderer, FromGlesError},
state::State,
utils::{iced::IcedElementInternal, prelude::*},
};
@ -657,13 +654,42 @@ impl CosmicMapped {
}
}
pub fn split_render_elements<R, C>(
pub fn popup_render_elements<R, C>(
&self,
renderer: &mut R,
location: smithay::utils::Point<i32, smithay::utils::Physical>,
scale: smithay::utils::Scale<f64>,
alpha: f32,
) -> SplitRenderElements<C>
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
C: From<CosmicMappedRenderElement<R>>,
{
match &self.element {
CosmicMappedInternal::Stack(s) => s
.popup_render_elements::<R, CosmicMappedRenderElement<R>>(
renderer, location, scale, alpha,
),
CosmicMappedInternal::Window(w) => w
.popup_render_elements::<R, CosmicMappedRenderElement<R>>(
renderer, location, scale, alpha,
),
_ => unreachable!(),
}
.into_iter()
.map(C::from)
.collect()
}
pub fn 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>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
@ -671,7 +697,7 @@ impl CosmicMapped {
C: From<CosmicMappedRenderElement<R>>,
{
#[cfg(feature = "debug")]
let debug_elements = if let Some(debug) = self.debug.lock().unwrap().as_mut() {
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) =
@ -840,30 +866,21 @@ impl CosmicMapped {
Vec::new()
};
#[cfg(not(feature = "debug"))]
let debug_elements = Vec::new();
let mut elements = SplitRenderElements {
w_elements: debug_elements,
p_elements: Vec::new(),
};
let mut elements = Vec::new();
#[cfg_attr(not(feature = "debug"), allow(unused_mut))]
elements.extend_map(
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!(),
},
C::from,
);
elements.extend(match &self.element {
CosmicMappedInternal::Stack(s) => s.render_elements::<R, CosmicMappedRenderElement<R>>(
renderer, location, scale, alpha,
),
CosmicMappedInternal::Window(w) => w
.render_elements::<R, CosmicMappedRenderElement<R>>(
renderer, location, scale, alpha,
),
_ => unreachable!(),
});
elements
elements.into_iter().map(C::from).collect()
}
pub(crate) fn update_theme(&self, theme: cosmic::Theme) {

59
src/shell/element/stack.rs
View file

@ -1,6 +1,6 @@
use super::{surface::RESIZE_BORDER, window::Focus, CosmicSurface};
use crate::{
backend::render::{cursor::CursorState, SplitRenderElements},
backend::render::cursor::CursorState,
shell::{
focus::target::PointerFocusTarget,
grabs::{ReleaseMode, ResizeEdge},
@ -541,13 +541,40 @@ impl CosmicStack {
self.0.loop_handle()
}
pub fn split_render_elements<R, C>(
pub fn popup_render_elements<R, C>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> SplitRenderElements<C>
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
C: From<CosmicStackRenderElement<R>>,
{
let window_loc = location + Point::from((0, (TAB_HEIGHT as f64 * scale.y) as i32));
self.0.with_program(|p| {
let windows = p.windows.lock().unwrap();
let active = p.active.load(Ordering::SeqCst);
windows[active]
.popup_render_elements::<R, CosmicStackRenderElement<R>>(
renderer, window_loc, scale, alpha,
)
.into_iter()
.map(C::from)
.collect()
})
}
pub fn render_elements<R, C>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
@ -564,28 +591,20 @@ impl CosmicStack {
let stack_loc = location + offset;
let window_loc = location + Point::from((0, (TAB_HEIGHT as f64 * scale.y) as i32));
let w_elements = AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(
let mut elements = AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(
&self.0, renderer, stack_loc, scale, alpha,
);
let mut elements = SplitRenderElements {
w_elements: w_elements.into_iter().map(C::from).collect(),
p_elements: Vec::new(),
};
elements.extend(self.0.with_program(|p| {
let windows = p.windows.lock().unwrap();
let active = p.active.load(Ordering::SeqCst);
elements.extend_map(
self.0.with_program(|p| {
let windows = p.windows.lock().unwrap();
let active = p.active.load(Ordering::SeqCst);
windows[active].render_elements::<R, CosmicStackRenderElement<R>>(
renderer, window_loc, scale, alpha,
)
}));
windows[active].split_render_elements::<R, CosmicStackRenderElement<R>>(
renderer, window_loc, scale, alpha,
)
}),
C::from,
);
elements
elements.into_iter().map(C::from).collect()
}
pub(crate) fn set_theme(&self, theme: cosmic::Theme) {

65
src/shell/element/surface.rs
View file

@ -35,7 +35,9 @@ use smithay::{
},
wayland_server::protocol::wl_surface::WlSurface,
},
utils::{user_data::UserDataMap, IsAlive, Logical, Rectangle, Serial, Size},
utils::{
user_data::UserDataMap, IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size,
},
wayland::{
compositor::{with_states, SurfaceData},
seat::WaylandFocus,
@ -45,7 +47,6 @@ use smithay::{
};
use crate::{
backend::render::SplitRenderElements,
state::{State, SurfaceDmabufFeedback},
utils::prelude::*,
wayland::handlers::decoration::PreferredDecorationMode,
@ -590,13 +591,13 @@ impl CosmicSurface {
self.0.user_data()
}
pub fn split_render_elements<R, C>(
pub fn popup_render_elements<R, C>(
&self,
renderer: &mut R,
location: smithay::utils::Point<i32, smithay::utils::Physical>,
scale: smithay::utils::Scale<f64>,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> SplitRenderElements<C>
) -> Vec<C>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
@ -605,9 +606,8 @@ impl CosmicSurface {
match self.0.underlying_surface() {
WindowSurface::Wayland(toplevel) => {
let surface = toplevel.wl_surface();
let p_elements = PopupManager::popups_for_surface(surface)
.flat_map(|(popup, popup_offset)| {
PopupManager::popups_for_surface(surface)
.flat_map(move |(popup, popup_offset)| {
let offset = (self.0.geometry().loc + popup_offset - popup.geometry().loc)
.to_physical_precise_round(scale);
@ -620,26 +620,40 @@ impl CosmicSurface {
element::Kind::Unspecified,
)
})
.collect();
.collect()
}
WindowSurface::X11(_) => Vec::new(),
}
}
let w_elements = render_elements_from_surface_tree(
pub fn render_elements<R, C>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> Vec<C>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: Clone + 'static,
C: From<WaylandSurfaceRenderElement<R>>,
{
match self.0.underlying_surface() {
WindowSurface::Wayland(toplevel) => {
let surface = toplevel.wl_surface();
render_elements_from_surface_tree(
renderer,
surface,
location,
scale,
alpha,
element::Kind::Unspecified,
);
SplitRenderElements {
w_elements,
p_elements,
}
)
}
WindowSurface::X11(surface) => {
surface.render_elements(renderer, location, scale, alpha)
}
WindowSurface::X11(surface) => SplitRenderElements {
w_elements: surface.render_elements(renderer, location, scale, alpha),
p_elements: Vec::new(),
},
}
}
@ -663,10 +677,7 @@ impl SpaceElement for CosmicSurface {
SpaceElement::bbox(&self.0)
}
fn is_in_input_region(
&self,
point: &smithay::utils::Point<f64, smithay::utils::Logical>,
) -> bool {
fn is_in_input_region(&self, point: &Point<f64, smithay::utils::Logical>) -> bool {
SpaceElement::is_in_input_region(&self.0, point)
}
@ -784,8 +795,8 @@ where
fn render_elements<C: From<Self::RenderElement>>(
&self,
renderer: &mut R,
location: smithay::utils::Point<i32, smithay::utils::Physical>,
scale: smithay::utils::Scale<f64>,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> Vec<C> {
self.0.render_elements(renderer, location, scale, alpha)

71
src/shell/element/window.rs
View file

@ -1,5 +1,5 @@
use crate::{
backend::render::{cursor::CursorState, SplitRenderElements},
backend::render::cursor::CursorState,
shell::{
focus::target::PointerFocusTarget,
grabs::{ReleaseMode, ResizeEdge},
@ -41,7 +41,7 @@ use smithay::{
output::Output,
reexports::wayland_server::protocol::wl_surface::WlSurface,
render_elements,
utils::{IsAlive, Logical, Point, Rectangle, Serial, Size},
utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size},
wayland::seat::WaylandFocus,
};
use std::{
@ -308,13 +308,13 @@ impl CosmicWindow {
self.0.loop_handle()
}
pub fn split_render_elements<R, C>(
pub fn popup_render_elements<R, C>(
&self,
renderer: &mut R,
location: smithay::utils::Point<i32, smithay::utils::Physical>,
scale: smithay::utils::Scale<f64>,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> SplitRenderElements<C>
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: Send + Clone + 'static,
@ -328,17 +328,44 @@ impl CosmicWindow {
location
};
let mut elements = SplitRenderElements::default();
self.0.with_program(|p| {
p.window
.popup_render_elements::<R, CosmicWindowRenderElement<R>>(
renderer, window_loc, scale, alpha,
)
.into_iter()
.map(C::from)
.collect()
})
}
elements.extend_map(
self.0.with_program(|p| {
p.window
.split_render_elements::<R, CosmicWindowRenderElement<R>>(
renderer, window_loc, scale, alpha,
)
}),
C::from,
);
pub fn render_elements<R, C>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
alpha: f32,
) -> Vec<C>
where
R: Renderer + ImportAll + ImportMem,
<R as Renderer>::TextureId: Send + Clone + '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 elements = Vec::new();
elements.extend(self.0.with_program(|p| {
p.window.render_elements::<R, CosmicWindowRenderElement<R>>(
renderer, window_loc, scale, alpha,
)
}));
if has_ssd {
let ssd_loc = location
@ -346,16 +373,12 @@ impl CosmicWindow {
.0
.with_program(|p| p.window.geometry().loc)
.to_physical_precise_round(scale);
elements.w_elements.extend(
AsRenderElements::<R>::render_elements::<CosmicWindowRenderElement<R>>(
&self.0, renderer, ssd_loc, scale, alpha,
)
.into_iter()
.map(C::from),
)
elements.extend(AsRenderElements::<R>::render_elements::<
CosmicWindowRenderElement<R>,
>(&self.0, renderer, ssd_loc, scale, alpha))
}
elements
elements.into_iter().map(C::from).collect()
}
pub(crate) fn set_theme(&self, theme: cosmic::Theme) {