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

window: Add window-specific debug overlay (not enabled)

Browse source
This commit is contained in:
Victoria Brekenfeld 2022-11-22 10:28:30 +01:00
parent 8430566e5e
commit e88f5898f7
7 changed files with 559 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,9 +1,25 @@
use crate::{state::State, utils::prelude::SeatExt};
use crate::{
backend::render::{
element::{AsGles2Frame, AsGlowRenderer, CosmicElement},
GlMultiRenderer,
},
state::State,
utils::prelude::SeatExt,
};
use id_tree::NodeId;
use smithay::{
backend::{
input::KeyState,
renderer::{element::AsRenderElements, ImportAll, Renderer},
renderer::{
element::{
texture::TextureRenderElement, AsRenderElements, Element, RenderElement,
UnderlyingStorage,
},
gles2::Gles2Texture,
glow::GlowRenderer,
multigpu::Error as MultiError,
ImportAll, Renderer,
},
},
desktop::{space::SpaceElement, Kind, PopupManager, Window, WindowSurfaceType},
input::{
@ -16,7 +32,7 @@ use smithay::{
wayland_protocols::xdg::shell::server::xdg_toplevel::State as XdgState,
wayland_server::{backend::ObjectId, protocol::wl_surface::WlSurface},
},
render_elements, space_elements,
space_elements,
utils::{IsAlive, Logical, Physical, Point, Rectangle, Scale, Serial, Size},
wayland::{
compositor::{with_states, with_surface_tree_downward, TraversalAction},
@ -26,6 +42,7 @@ use smithay::{
};
use std::{
collections::HashMap,
fmt,
hash::Hash,
sync::{Arc, Mutex},
};
@ -35,6 +52,11 @@ pub use self::stack::CosmicStack;
pub mod window;
pub use self::window::CosmicWindow;
#[cfg(feature = "debug")]
use smithay::wayland::shell::xdg::XdgToplevelSurfaceData;
#[cfg(feature = "debug")]
use smithay_egui::EguiState;
use super::{focus::FocusDirection, layout::floating::ResizeState};
space_elements! {
@ -44,7 +66,7 @@ space_elements! {
Stack=CosmicStack,
}
#[derive(Debug, Clone)]
#[derive(Clone)]
pub struct CosmicMapped {
element: CosmicMappedInternal,
@ -56,6 +78,20 @@ pub struct CosmicMapped {
//floating
pub(super) last_geometry: Arc<Mutex<Option<Rectangle<i32, Logical>>>>,
pub(super) resize_state: Arc<Mutex<Option<ResizeState>>>,
#[cfg(feature = "debug")]
debug: Arc<Mutex<smithay_egui::EguiState>>,
}
impl fmt::Debug for CosmicMapped {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("CosmicMapped")
.field("element", &self.element)
.field("last_cursor_position", &self.last_cursor_position)
.field("tiling_node_id", &self.tiling_node_id)
.field("resize_state", &self.resize_state)
.finish()
}
}
impl PartialEq for CosmicMapped {
@ -239,8 +275,7 @@ impl CosmicMapped {
Kind::Xdg(xdg) => {
xdg.current_state().states.contains(XdgState::Resizing)
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Resizing))
}
// Kind::X11?
} // Kind::X11?
}
}
@ -387,8 +422,7 @@ impl CosmicMapped {
Kind::Xdg(xdg) => {
xdg.current_state().states.contains(XdgState::Activated)
|| xdg.with_pending_state(|states| states.states.contains(XdgState::Activated))
}
// Kind::X11?
} // Kind::X11?
}
}
@ -687,6 +721,10 @@ impl From<CosmicWindow> for CosmicMapped {
tiling_node_id: Arc::new(Mutex::new(None)),
last_geometry: Arc::new(Mutex::new(None)),
resize_state: Arc::new(Mutex::new(None)),
#[cfg(feature = "debug")]
debug: Arc::new(Mutex::new(smithay_egui::EguiState::new(
Rectangle::from_loc_and_size((10, 10), (100, 100)),
))),
}
}
}
@ -699,20 +737,235 @@ impl From<CosmicStack> for CosmicMapped {
tiling_node_id: Arc::new(Mutex::new(None)),
last_geometry: Arc::new(Mutex::new(None)),
resize_state: Arc::new(Mutex::new(None)),
#[cfg(feature = "debug")]
debug: Arc::new(Mutex::new(smithay_egui::EguiState::new(
Rectangle::from_loc_and_size((10, 10), (100, 100)),
))),
}
}
}
render_elements! {
pub CosmicMappedRenderElement<R> where R: ImportAll;
Stack=self::stack::CosmicStackRenderElement<R>,
Window=self::window::CosmicWindowRenderElement<R>,
pub enum CosmicMappedRenderElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
{
Stack(self::stack::CosmicStackRenderElement<R>),
Window(self::window::CosmicWindowRenderElement<R>),
#[cfg(feature = "debug")]
Egui(TextureRenderElement<Gles2Texture>),
}
impl<R> Element for CosmicMappedRenderElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
{
fn id(&self) -> &smithay::backend::renderer::element::Id {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.id(),
CosmicMappedRenderElement::Window(elem) => elem.id(),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => elem.id(),
}
}
fn current_commit(&self) -> smithay::backend::renderer::utils::CommitCounter {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.current_commit(),
CosmicMappedRenderElement::Window(elem) => elem.current_commit(),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => elem.current_commit(),
}
}
fn src(&self) -> Rectangle<f64, smithay::utils::Buffer> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.src(),
CosmicMappedRenderElement::Window(elem) => elem.src(),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => elem.src(),
}
}
fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.geometry(scale),
CosmicMappedRenderElement::Window(elem) => elem.geometry(scale),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => elem.geometry(scale),
}
}
fn location(&self, scale: Scale<f64>) -> Point<i32, Physical> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.location(scale),
CosmicMappedRenderElement::Window(elem) => elem.location(scale),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => elem.location(scale),
}
}
fn transform(&self) -> smithay::utils::Transform {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.transform(),
CosmicMappedRenderElement::Window(elem) => elem.transform(),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => elem.transform(),
}
}
fn damage_since(
&self,
scale: Scale<f64>,
commit: Option<smithay::backend::renderer::utils::CommitCounter>,
) -> Vec<Rectangle<i32, Physical>> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.damage_since(scale, commit),
CosmicMappedRenderElement::Window(elem) => elem.damage_since(scale, commit),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => elem.damage_since(scale, commit),
}
}
fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.opaque_regions(scale),
CosmicMappedRenderElement::Window(elem) => elem.opaque_regions(scale),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => elem.opaque_regions(scale),
}
}
}
impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
fn draw(
&self,
renderer: &mut GlowRenderer,
frame: &mut <GlowRenderer as Renderer>::Frame,
location: Point<i32, Physical>,
scale: Scale<f64>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicMappedRenderElement::Stack(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
CosmicMappedRenderElement::Window(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
}
}
fn underlying_storage(
&self,
renderer: &GlowRenderer,
) -> Option<UnderlyingStorage<'_, GlowRenderer>> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.underlying_storage(renderer),
CosmicMappedRenderElement::Window(elem) => elem.underlying_storage(renderer),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => elem.underlying_storage(renderer),
}
}
}
impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicMappedRenderElement<GlMultiRenderer<'a>> {
fn draw(
&self,
renderer: &mut GlMultiRenderer<'a>,
frame: &mut <GlMultiRenderer<'a> as Renderer>::Frame,
location: Point<i32, Physical>,
scale: Scale<f64>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlMultiRenderer<'_> as Renderer>::Error> {
match self {
CosmicMappedRenderElement::Stack(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
CosmicMappedRenderElement::Window(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
let glow_renderer = renderer.glow_renderer_mut();
let gles2_frame = frame.gles2_frame_mut();
elem.draw(glow_renderer, gles2_frame, location, scale, damage, log)
.map_err(|err| MultiError::Render(err))
}
}
}
fn underlying_storage(
&self,
renderer: &GlMultiRenderer<'a>,
) -> Option<UnderlyingStorage<'_, GlMultiRenderer<'a>>> {
match self {
CosmicMappedRenderElement::Stack(elem) => elem.underlying_storage(renderer),
CosmicMappedRenderElement::Window(elem) => elem.underlying_storage(renderer),
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
let glow_renderer = renderer.glow_renderer();
match elem.underlying_storage(glow_renderer) {
Some(UnderlyingStorage::Wayland(buffer)) => {
Some(UnderlyingStorage::Wayland(buffer))
}
_ => None,
}
}
}
}
}
impl<R> From<stack::CosmicStackRenderElement<R>> for CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: stack::CosmicStackRenderElement<R>) -> Self {
CosmicMappedRenderElement::Stack(elem)
}
}
impl<R> From<window::CosmicWindowRenderElement<R>> for CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: window::CosmicWindowRenderElement<R>) -> Self {
CosmicMappedRenderElement::Window(elem)
}
}
#[cfg(feature = "debug")]
impl<R> From<TextureRenderElement<Gles2Texture>> for CosmicMappedRenderElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: TextureRenderElement<Gles2Texture>) -> Self {
CosmicMappedRenderElement::Egui(elem)
}
}
impl<R> AsRenderElements<R> for CosmicMapped
where
R: Renderer + ImportAll,
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
type RenderElement = CosmicMappedRenderElement<R>;
fn render_elements<C: From<Self::RenderElement>>(
@ -720,7 +973,7 @@ where
location: Point<i32, Physical>,
scale: Scale<f64>,
) -> Vec<C> {
match &self.element {
let mut elements = match &self.element {
CosmicMappedInternal::Stack(s) => AsRenderElements::<R>::render_elements::<
CosmicMappedRenderElement<R>,
>(s, location, scale),
@ -728,9 +981,121 @@ where
CosmicMappedRenderElement<R>,
>(w, location, scale),
_ => Vec::new(),
};
/*
#[cfg(feature = "debug")]
if !elements.is_empty() {
let window = self.active_window();
let (app_id, title, min_size, max_size, size, states) = with_states(&window.kind().wl_surface(), |states| {
let attributes = states
.data_map
.get::<XdgToplevelSurfaceData>()
.unwrap()
.lock()
.unwrap();
(attributes.app_id.clone(), attributes.title.clone(), attributes.min_size.clone(), attributes.max_size.clone(), attributes.current.size.clone(), attributes.current.states.clone())
});
let win_geo = self.geometry().size;
let area = {
let size = win_size.clamp((10, 10), (100, 100))};
let offset = (win_size - (100, 100).into())
.to_point()
.constain(Rectangle::from_loc_and_size((0, 0), (10, 10)));
Rectangle::from_loc_and_size(offset, size)
};
match self.debug.lock().unwrap().render(
|ui| {
egui::Frame::none()
.fill(Color32::DARK_GRAY)
.rounding(0.25)
.show(ui, |ui| {
ui.heading(title.as_deref().unwrap_or("<None>"));
ui.label(app_id.as_deref().unwrap_or("<None>"));
ui.horizontal(|ui| {
ui.label("States: ");
if states.contains(XdgState::Maximized) {
ui.label("🗖");
}
if states.contains(XdgState::Fullscreen) {
ui.label("⬜")
}
if states.contains(XdgState::Activated) {
ui.label("🖱")
}
if states.contains(XdgState::Resizing) {
ui.label("↔")
}
if states.contains(XdgState::TiledLeft) {
ui.label("⏴")
}
if states.contains(XdgState::TiledRight) {
ui.label("⏵")
}
if states.contains(XdgState::TiledTop) {
ui.label("⏶")
}
if states.contains(XdgState::TiledBottom) {
ui.label("⏷")
}
});
let plot = Plot::new("Sizes")
.legend(Legend::default().position(Corner::RightBottom))
.show_x(false)
.show_y(false)
.data_aspect(0.1);
plot.show(ui, |plot_ui| {
let center = ((max_size.w + 20) / 2, (max_size.h + 20) / 2);
let max_size_rect = Polygon::new(PlotPoints::new(vec![
(10, 10),
(max_size.w + 10, 10),
(max_size.w + 10, max_size.h + 10),
(10, max_size.h + 10),
(10, 10),
]));
plot_ui.polygon(max_size_rect.name(format!("{}", max_size)));
if let Some(size) = size {
let size_rect = Polygon::new(PlotPoints::new(vec![
(center.0 - size.w / 2, center.1 - size.h / 2),
(center.0 + size.w / 2, center.1 - size.w / 2),
(center.0 + size.w / 2, center.1 + size.w / 2),
(center.0 - size.w / 2, center.1 + size.w / 2),
(center.0 - size.w / 2, center.1 - size.w / 2),
]));
plot_ui.polygon(size_rect.name(format!("{}", size)));
}
let min_size_rect = Polygon::new(PlotPoints::new(vec![
(center.0 - min_size.w / 2, center.1 - min_size.h / 2),
(center.0 + min_size.w / 2, center.1 - min_size.w / 2),
(center.0 + min_size.w / 2, center.1 + min_size.w / 2),
(center.0 - min_size.w / 2, center.1 + min_size.w / 2),
(center.0 - min_size.w / 2, center.1 - min_size.w / 2),
]));
plot_ui.polygon(min_size_rect.name(format!("{}", min_size)));
})
});
},
renderer,
area,
scale,
if self.last_cursor_position.lock().unwrap().values().any(|p| area.contains(p.to_i32_round())) {
0.4
} else {
1.0
},
start_time,
) {
Ok(element) => elements.push(element),
Err(err) => slog_scope::debug!("Error rendering debug overlay: {}", err),
};
}
.into_iter()
.map(C::from)
.collect()
*/
elements.into_iter().map(C::from).collect()
}
}

10
src/shell/layout/floating/grabs/moving.rs
View file

@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::{
backend::render::element::{AsGles2Frame, AsGlowRenderer},
shell::{
element::{CosmicMapped, CosmicMappedRenderElement},
focus::target::{KeyboardFocusTarget, PointerFocusTarget},
@ -9,7 +10,10 @@ use crate::{
};
use smithay::{
backend::renderer::{element::AsRenderElements, ImportAll, Renderer},
backend::renderer::{
element::{AsRenderElements, RenderElement},
ImportAll, Renderer,
},
desktop::space::SpaceElement,
input::{
pointer::{
@ -35,8 +39,10 @@ pub struct MoveGrabState {
impl MoveGrabState {
pub fn render<I, R>(&self, seat: &Seat<State>, output: &Output) -> Vec<I>
where
R: Renderer + ImportAll,
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
I: From<CosmicMappedRenderElement<R>>,
{
let cursor_at = seat.get_pointer().unwrap().current_location();

20
src/shell/layout/floating/mod.rs
View file

@ -1,16 +1,16 @@
// SPDX-License-Identifier: GPL-3.0-only
use smithay::{
backend::renderer::{ImportAll, Renderer},
backend::renderer::{element::RenderElement, ImportAll, Renderer},
desktop::{layer_map_for_output, space::SpaceElement, Space, Window},
input::{pointer::GrabStartData as PointerGrabStartData, Seat},
output::Output,
render_elements,
utils::{Logical, Point, Rectangle, Serial},
};
use std::collections::HashMap;
use crate::{
backend::render::element::{AsGles2Frame, AsGlowRenderer},
shell::{
element::{CosmicMapped, CosmicMappedRenderElement},
grabs::ResizeEdge,
@ -295,23 +295,17 @@ impl FloatingLayout {
pub fn render_output<R>(
&self,
output: &Output,
) -> Result<Vec<FloatingRenderElement<R>>, OutputNotMapped>
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
where
R: Renderer + ImportAll,
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
let output_scale = output.current_scale().fractional_scale();
let output_geo = self.space.output_geometry(output).ok_or(OutputNotMapped)?;
Ok(self
.space
.render_elements_for_region::<R, _>(&output_geo, output_scale)
.into_iter()
.map(FloatingRenderElement::from)
.collect())
.render_elements_for_region::<R, _>(&output_geo, output_scale))
}
}
render_elements! {
pub FloatingRenderElement<R> where R: ImportAll;
Window=CosmicMappedRenderElement<R>,
}

20
src/shell/layout/tiling/mod.rs
View file

@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::{
backend::render::element::{AsGles2Frame, AsGlowRenderer},
shell::{
element::{CosmicMapped, CosmicMappedRenderElement},
focus::{
@ -17,11 +18,13 @@ use crate::{
use id_tree::{InsertBehavior, MoveBehavior, Node, NodeId, NodeIdError, RemoveBehavior, Tree};
use smithay::{
backend::renderer::{element::AsRenderElements, ImportAll, Renderer},
backend::renderer::{
element::{AsRenderElements, RenderElement},
ImportAll, Renderer,
},
desktop::{layer_map_for_output, space::SpaceElement, PopupKind, Window},
input::{pointer::GrabStartData as PointerGrabStartData, Seat},
output::Output,
render_elements,
utils::{IsAlive, Logical, Point, Rectangle, Scale, Serial},
};
use std::{borrow::Borrow, collections::HashMap, hash::Hash, sync::Arc};
@ -1222,10 +1225,12 @@ impl TilingLayout {
pub fn render_output<R>(
&self,
output: &Output,
) -> Result<Vec<TilingRenderElement<R>>, OutputNotMapped>
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
where
R: Renderer + ImportAll,
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
let output_scale = output.current_scale().fractional_scale();
@ -1243,7 +1248,7 @@ impl TilingLayout {
}
})
.flat_map(|(mapped, loc)| {
AsRenderElements::<R>::render_elements::<TilingRenderElement<R>>(
AsRenderElements::<R>::render_elements::<CosmicMappedRenderElement<R>>(
mapped,
loc.to_physical_precise_round(output_scale)
- mapped
@ -1256,8 +1261,3 @@ impl TilingLayout {
.collect::<Vec<_>>())
}
}
render_elements! {
pub TilingRenderElement<R> where R: ImportAll;
Window=CosmicMappedRenderElement<R>,
}

151
src/shell/workspace.rs
View file

@ -1,4 +1,5 @@
use crate::{
backend::render::element::{AsGles2Frame, AsGlowRenderer},
shell::layout::{
floating::{FloatingLayout, MoveSurfaceGrab},
tiling::TilingLayout,
@ -17,7 +18,7 @@ use crate::{
use indexmap::IndexSet;
use smithay::{
backend::renderer::{
element::{surface::WaylandSurfaceRenderElement, AsRenderElements},
element::{surface::WaylandSurfaceRenderElement, AsRenderElements, Element, RenderElement},
ImportAll, Renderer,
},
desktop::{layer_map_for_output, space::SpaceElement, Kind, LayerSurface, Window},
@ -27,7 +28,6 @@ use smithay::{
wayland_protocols::xdg::shell::server::xdg_toplevel::{self, ResizeEdge},
wayland_server::protocol::wl_surface::WlSurface,
},
render_elements,
utils::{IsAlive, Logical, Point, Rectangle, Scale, Serial},
wayland::shell::wlr_layer::Layer,
};
@ -37,7 +37,7 @@ use super::{
element::CosmicMapped,
focus::{FocusStack, FocusStackMut},
grabs::ResizeGrab,
layout::{floating::FloatingRenderElement, tiling::TilingRenderElement},
CosmicMappedRenderElement,
};
#[derive(Debug)]
@ -422,8 +422,10 @@ impl Workspace {
output: &Output,
) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped>
where
R: Renderer + ImportAll,
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
let mut render_elements = Vec::new();
@ -540,9 +542,140 @@ impl FocusStacks {
pub struct OutputNotMapped;
render_elements! {
pub WorkspaceRenderElement<R> where R: ImportAll;
Wayland=WaylandSurfaceRenderElement,
Floating=FloatingRenderElement<R>,
Tiling=TilingRenderElement<R>,
pub enum WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
{
Wayland(WaylandSurfaceRenderElement),
Window(CosmicMappedRenderElement<R>),
}
impl<R> Element for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
{
fn id(&self) -> &smithay::backend::renderer::element::Id {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.id(),
WorkspaceRenderElement::Window(elem) => elem.id(),
}
}
fn current_commit(&self) -> smithay::backend::renderer::utils::CommitCounter {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.current_commit(),
WorkspaceRenderElement::Window(elem) => elem.current_commit(),
}
}
fn src(&self) -> Rectangle<f64, smithay::utils::Buffer> {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.src(),
WorkspaceRenderElement::Window(elem) => elem.src(),
}
}
fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, smithay::utils::Physical> {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.geometry(scale),
WorkspaceRenderElement::Window(elem) => elem.geometry(scale),
}
}
fn location(&self, scale: Scale<f64>) -> Point<i32, smithay::utils::Physical> {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.location(scale),
WorkspaceRenderElement::Window(elem) => elem.location(scale),
}
}
fn transform(&self) -> smithay::utils::Transform {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.transform(),
WorkspaceRenderElement::Window(elem) => elem.transform(),
}
}
fn damage_since(
&self,
scale: Scale<f64>,
commit: Option<smithay::backend::renderer::utils::CommitCounter>,
) -> Vec<Rectangle<i32, smithay::utils::Physical>> {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.damage_since(scale, commit),
WorkspaceRenderElement::Window(elem) => elem.damage_since(scale, commit),
}
}
fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, smithay::utils::Physical>> {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.opaque_regions(scale),
WorkspaceRenderElement::Window(elem) => elem.opaque_regions(scale),
}
}
}
impl<R> RenderElement<R> for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn draw(
&self,
renderer: &mut R,
frame: &mut <R as Renderer>::Frame,
location: Point<i32, smithay::utils::Physical>,
scale: Scale<f64>,
damage: &[Rectangle<i32, smithay::utils::Physical>],
log: &slog::Logger,
) -> Result<(), <R as Renderer>::Error> {
match self {
WorkspaceRenderElement::Wayland(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
WorkspaceRenderElement::Window(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
}
}
fn underlying_storage(
&self,
renderer: &R,
) -> Option<smithay::backend::renderer::element::UnderlyingStorage<'_, R>> {
match self {
WorkspaceRenderElement::Wayland(elem) => elem.underlying_storage(renderer),
WorkspaceRenderElement::Window(elem) => elem.underlying_storage(renderer),
}
}
}
impl<R> From<WaylandSurfaceRenderElement> for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: WaylandSurfaceRenderElement) -> Self {
WorkspaceRenderElement::Wayland(elem)
}
}
impl<R> From<CosmicMappedRenderElement<R>> for WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CosmicMappedRenderElement<R>) -> Self {
WorkspaceRenderElement::Window(elem)
}
}