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

deps: Update smithay

Browse source 
- Use new GAT frame
- Bugfixes
- Finish window debug overlay
This commit is contained in:
Victoria Brekenfeld 2022-11-28 17:48:50 +01:00
parent c585811cab
commit 7092c523f5
18 changed files with 445 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

61
Cargo.lock generated
View file

@ -327,6 +327,7 @@ dependencies = [
"libsystemd",
"png",
"regex",
"renderdoc",
"ron",
"sendfd",
"serde",
@ -666,12 +667,21 @@ dependencies = [
[[package]]
name = "flate2"
version = "1.0.24"
version = "1.0.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
checksum = "a8a2db397cb1c8772f31494cb8917e48cd1e64f0fa7efac59fbd741a0a8ce841"
dependencies = [
"crc32fast",
"miniz_oxide 0.5.4",
"miniz_oxide 0.6.2",
]
[[package]]
name = "float-cmp"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1267f4ac4f343772758f7b1bdcbe767c218bbab93bb432acbf5162bbf85a6c4"
dependencies = [
"num-traits",
]
[[package]]
@ -1535,6 +1545,27 @@ dependencies = [
"winapi",
]
[[package]]
name = "renderdoc"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b42e14087d51efd3b42eb341e37b6f320af2b0750519ea849cb68bb7289643ed"
dependencies = [
"bitflags",
"float-cmp 0.8.0",
"libloading",
"once_cell",
"renderdoc-sys",
"winapi",
"wio",
]
[[package]]
name = "renderdoc-sys"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1382d1f0a252c4bf97dc20d979a2fdd05b024acd7c2ed0f7595d7817666a157"
[[package]]
name = "resvg"
version = "0.23.0"
@ -1789,7 +1820,7 @@ checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
[[package]]
name = "smithay"
version = "0.3.0"
source = "git+https://github.com/pop-os/smithay?rev=c8aaa059e8#c8aaa059e841886ed9e689e0cc0d0cb821b97b71"
source = "git+https://github.com/pop-os/smithay?rev=8f6261bbf6#8f6261bbf6b2158e5cb451c6537378772eae7fe2"
dependencies = [
"appendlist",
"bitflags",
@ -1805,7 +1836,6 @@ dependencies = [
"glow",
"indexmap",
"input",
"io-lifetimes",
"lazy_static",
"libc",
"libloading",
@ -1854,7 +1884,7 @@ dependencies = [
[[package]]
name = "smithay-egui"
version = "0.1.0"
source = "git+https://github.com/Smithay/smithay-egui.git?rev=9fe1fa5e01#9fe1fa5e01dc39c145f036564e971a50f84864ff"
source = "git+https://github.com/Smithay/smithay-egui.git?rev=13626ad3f4#13626ad3f41a6f877929802eb645a10e5bd1abae"
dependencies = [
"cgmath",
"egui",
@ -1890,7 +1920,7 @@ version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "639abcebc15fdc2df179f37d6f5463d660c1c79cd552c12343a4600827a04bce"
dependencies = [
"float-cmp",
"float-cmp 0.9.0",
"rgb",
]
@ -2126,7 +2156,7 @@ dependencies = [
"base64",
"data-url",
"flate2",
"float-cmp",
"float-cmp 0.9.0",
"fontdb",
"kurbo",
"log",
@ -2581,10 +2611,19 @@ dependencies = [
]
[[package]]
name = "x11-dl"
version = "2.20.0"
name = "wio"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c83627bc137605acc00bb399c7b908ef460b621fc37c953db2b09f88c449ea6"
checksum = "5d129932f4644ac2396cb456385cbf9e63b5b30c6e8dc4820bdca4eb082037a5"
dependencies = [
"winapi",
]
[[package]]
name = "x11-dl"
version = "2.20.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b1536d6965a5d4e573c7ef73a2c15ebcd0b2de3347bdf526c34c297c00ac40f0"
dependencies = [
"lazy_static",
"libc",

9
Cargo.toml
View file

@ -17,6 +17,7 @@ serde = { version = "1", features = ["derive"] }
serde_json = "1"
sendfd = "0.4.1"
egui = { version = "0.19.0", optional = true }
renderdoc = { version = "0.10.1", optional = true }
edid-rs = { version = "0.1" }
png = "0.17.5"
lazy_static = "1.4.0"
@ -36,19 +37,19 @@ cosmic-protocols = { git = "https://github.com/pop-os/cosmic-protocols", branch
[dependencies.smithay]
version = "0.3"
git = "https://github.com/Smithay/smithay.git"
rev = "b297c93edc"
rev = "2de946cf9e"
default-features = false
features = ["backend_drm", "backend_gbm", "backend_egl", "backend_libinput", "backend_session_libseat", "backend_udev", "backend_winit", "backend_x11", "desktop", "use_system_lib", "renderer_glow", "renderer_multi", "wayland_frontend", "slog-stdlog"]
[dependencies.smithay-egui]
git = "https://github.com/Smithay/smithay-egui.git"
rev = "9fe1fa5e01"
rev = "13626ad3f4"
features = ["svg"]
optional = true
[features]
default = []
debug = ["egui", "smithay-egui"]
debug = ["egui", "smithay-egui", "renderdoc"]
[profile.dev]
lto = "thin"
@ -61,4 +62,4 @@ debug = true
lto = "fat"
[patch."https://github.com/Smithay/smithay.git"]
smithay = { git = "https://github.com/pop-os/smithay", rev = "c8aaa059e8" }
smithay = { git = "https://github.com/pop-os/smithay", rev = "8f6261bbf6" }

28
src/backend/render/cursor.rs
View file

@ -129,15 +129,18 @@ fn load_icon(theme: &CursorTheme) -> Result<Vec<Image>, Error> {
render_elements! {
pub CursorRenderElement<R> where R: ImportAll;
Static=TextureRenderElement<<R as Renderer>::TextureId>,
Surface=WaylandSurfaceRenderElement,
Surface=WaylandSurfaceRenderElement<R>,
}
pub fn draw_surface_cursor<R: Renderer + ImportAll>(
pub fn draw_surface_cursor<R>(
renderer: &mut R,
surface: &wl_surface::WlSurface,
location: impl Into<Point<i32, Logical>>,
scale: impl Into<Scale<f64>>,
) -> Vec<CursorRenderElement<R>>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: 'static,
{
let mut position = location.into();
let scale = scale.into();
@ -152,14 +155,25 @@ where
});
position -= h;
render_elements_from_surface_tree(surface, position.to_physical_precise_round(scale), scale)
render_elements_from_surface_tree(
renderer,
surface,
position.to_physical_precise_round(scale),
scale,
slog_scope::logger(),
)
}
pub fn draw_dnd_icon<R: Renderer + ImportAll>(
pub fn draw_dnd_icon<R>(
renderer: &mut R,
surface: &wl_surface::WlSurface,
location: impl Into<Point<i32, Logical>>,
scale: impl Into<Scale<f64>>,
) -> Vec<CursorRenderElement<R>> {
) -> Vec<CursorRenderElement<R>>
where
R: Renderer + ImportAll,
<R as Renderer>::TextureId: 'static,
{
if get_role(&surface) != Some("dnd_icon") {
slog_scope::warn!(
"Trying to display as a dnd icon a surface that does not have the DndIcon role."
@ -167,9 +181,11 @@ pub fn draw_dnd_icon<R: Renderer + ImportAll>(
}
let scale = scale.into();
render_elements_from_surface_tree(
renderer,
surface,
location.into().to_physical_precise_round(scale),
scale,
slog_scope::logger(),
)
}
@ -218,7 +234,7 @@ where
.unwrap_or(CursorImageStatus::Default);
if let CursorImageStatus::Surface(ref wl_surface) = cursor_status {
return draw_surface_cursor(wl_surface, location.to_i32_round(), scale);
return draw_surface_cursor(renderer, wl_surface, location.to_i32_round(), scale);
} else if draw_default && CursorImageStatus::Default == cursor_status {
let integer_scale = scale.x.max(scale.y).ceil() as u32;

80
src/backend/render/element.rs
View file

@ -2,22 +2,24 @@ use crate::shell::{CosmicMappedRenderElement, WorkspaceRenderElement};
use smithay::{
backend::renderer::{
element::{texture::TextureRenderElement, Element, RenderElement, UnderlyingStorage},
gles2::{Gles2Frame, Gles2Texture},
glow::GlowRenderer,
multigpu::Error as MultiError,
element::{Element, RenderElement, UnderlyingStorage},
glow::{GlowFrame, GlowRenderer},
Frame, ImportAll, Renderer,
},
utils::{Physical, Point, Rectangle, Scale},
};
#[cfg(feature = "debug")]
use smithay::backend::renderer::{
element::texture::TextureRenderElement, gles2::Gles2Texture, multigpu::Error as MultiError,
};
use super::{cursor::CursorRenderElement, GlMultiFrame, GlMultiRenderer};
pub enum CosmicElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
Workspace(WorkspaceRenderElement<R>),
@ -31,7 +33,6 @@ impl<R> Element for CosmicElement<R>
where
R: AsGlowRenderer + Renderer + ImportAll,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn id(&self) -> &smithay::backend::renderer::element::Id {
@ -120,25 +121,22 @@ where
}
impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
fn draw(
fn draw<'frame>(
&self,
renderer: &mut GlowRenderer,
frame: &mut <GlowRenderer as Renderer>::Frame,
frame: &mut <GlowRenderer as Renderer>::Frame<'frame>,
location: Point<i32, Physical>,
scale: Scale<f64>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicElement::Workspace(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
CosmicElement::Cursor(elem) => elem.draw(renderer, frame, location, scale, damage, log),
CosmicElement::MoveGrab(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
CosmicElement::Workspace(elem) => elem.draw(frame, location, scale, damage, log),
CosmicElement::Cursor(elem) => elem.draw(frame, location, scale, damage, log),
CosmicElement::MoveGrab(elem) => elem.draw(frame, location, scale, damage, log),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => elem.draw(renderer, frame, location, scale, damage, log),
CosmicElement::Egui(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, location, scale, damage, log)
}
}
}
@ -157,29 +155,28 @@ impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
}
impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicElement<GlMultiRenderer<'a>> {
fn draw(
fn draw<'frame>(
&self,
renderer: &mut GlMultiRenderer<'a>,
frame: &mut <GlMultiRenderer<'a> as Renderer>::Frame,
frame: &mut GlMultiFrame<'a, 'frame>,
location: Point<i32, Physical>,
scale: Scale<f64>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlMultiRenderer<'_> as Renderer>::Error> {
match self {
CosmicElement::Workspace(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
CosmicElement::Cursor(elem) => elem.draw(renderer, frame, location, scale, damage, log),
CosmicElement::MoveGrab(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
}
CosmicElement::Workspace(elem) => elem.draw(frame, location, scale, damage, log),
CosmicElement::Cursor(elem) => elem.draw(frame, location, scale, damage, log),
CosmicElement::MoveGrab(elem) => elem.draw(frame, location, scale, damage, log),
#[cfg(feature = "debug")]
CosmicElement::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)
let elem = {
let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(
elem, glow_frame, location, scale, damage, log,
)
.map_err(|err| MultiError::Render(err))
};
elem
}
}
}
@ -210,7 +207,6 @@ impl<R> From<WorkspaceRenderElement<R>> for CosmicElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: WorkspaceRenderElement<R>) -> Self {
@ -222,7 +218,6 @@ impl<R> From<CursorRenderElement<R>> for CosmicElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: CursorRenderElement<R>) -> Self {
@ -234,7 +229,6 @@ impl<R> From<CosmicMappedRenderElement<R>> for CosmicElement<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 {
@ -247,7 +241,6 @@ impl<R> From<TextureRenderElement<Gles2Texture>> for CosmicElement<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 {
@ -258,7 +251,6 @@ where
pub trait AsGlowRenderer
where
Self: Renderer,
<Self as Renderer>::Frame: AsGles2Frame,
{
fn glow_renderer(&self) -> &GlowRenderer;
fn glow_renderer_mut(&mut self) -> &mut GlowRenderer;
@ -282,28 +274,28 @@ impl<'a> AsGlowRenderer for GlMultiRenderer<'a> {
}
}
pub trait AsGles2Frame
pub trait AsGlowFrame<'a>
where
Self: Frame,
{
fn gles2_frame(&self) -> &Gles2Frame;
fn gles2_frame_mut(&mut self) -> &mut Gles2Frame;
fn glow_frame(&self) -> &GlowFrame<'a>;
fn glow_frame_mut(&mut self) -> &mut GlowFrame<'a>;
}
impl AsGles2Frame for Gles2Frame {
fn gles2_frame(&self) -> &Gles2Frame {
impl<'frame> AsGlowFrame<'frame> for GlowFrame<'frame> {
fn glow_frame(&self) -> &GlowFrame<'frame> {
self
}
fn gles2_frame_mut(&mut self) -> &mut Gles2Frame {
fn glow_frame_mut(&mut self) -> &mut GlowFrame<'frame> {
self
}
}
impl AsGles2Frame for GlMultiFrame {
fn gles2_frame(&self) -> &Gles2Frame {
impl<'renderer, 'frame> AsGlowFrame<'frame> for GlMultiFrame<'renderer, 'frame> {
fn glow_frame(&self) -> &GlowFrame<'frame> {
self.as_ref()
}
fn gles2_frame_mut(&mut self) -> &mut Gles2Frame {
fn glow_frame_mut(&mut self) -> &mut GlowFrame<'frame> {
self.as_mut()
}
}

42
src/backend/render/mod.rs
View file

@ -41,7 +41,7 @@ use smithay::{
pub mod cursor;
use self::cursor::CursorRenderElement;
pub mod element;
use self::element::{AsGles2Frame, AsGlowRenderer, CosmicElement};
use self::element::{AsGlowRenderer, CosmicElement};
pub type GlMultiRenderer<'a> = MultiRenderer<
'a,
@ -50,7 +50,14 @@ pub type GlMultiRenderer<'a> = MultiRenderer<
EglGlesBackend<GlowRenderer>,
Gles2Renderbuffer,
>;
pub type GlMultiFrame = MultiFrame<EglGlesBackend<GlowRenderer>, EglGlesBackend<GlowRenderer>>;
pub type GlMultiFrame<'a, 'frame> = MultiFrame<
'a,
'a,
'frame,
EglGlesBackend<GlowRenderer>,
EglGlesBackend<GlowRenderer>,
Gles2Renderbuffer,
>;
pub static CLEAR_COLOR: [f32; 4] = [0.153, 0.161, 0.165, 1.0];
@ -61,7 +68,7 @@ pub enum CursorMode {
All,
}
pub fn cursor_elements<E, R>(
pub fn cursor_elements<'frame, E, R>(
renderer: &mut R,
state: &Common,
output: &Output,
@ -69,7 +76,6 @@ pub fn cursor_elements<E, R>(
) -> Vec<E>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::Frame: AsGles2Frame,
<R as Renderer>::TextureId: Clone + 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
E: From<CursorRenderElement<R>> + From<CosmicMappedRenderElement<R>>,
@ -101,7 +107,7 @@ where
if let Some(wl_surface) = get_dnd_icon(seat) {
elements.extend(
cursor::draw_dnd_icon(&wl_surface, location.to_i32_round(), scale)
cursor::draw_dnd_icon(renderer, &wl_surface, location.to_i32_round(), scale)
.into_iter()
.map(E::from),
);
@ -113,7 +119,7 @@ where
.unwrap()
.borrow()
.as_ref()
.map(|state| state.render::<E, R>(seat, output))
.map(|state| state.render::<E, R>(renderer, seat, output))
{
elements.extend(grab_elements);
}
@ -122,7 +128,7 @@ where
elements
}
pub fn render_output<R, Target, OffTarget, Source>(
pub fn render_output<'frame, R, Target, OffTarget, Source>(
gpu: Option<&DrmNode>,
renderer: &mut R,
target: Target,
@ -144,7 +150,6 @@ where
+ Offscreen<OffTarget>
+ Blit<Source>
+ AsGlowRenderer,
<R as Renderer>::Frame: AsGles2Frame,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
CosmicElement<R>: RenderElement<R>,
@ -167,7 +172,7 @@ where
)
}
pub fn render_workspace<R, Target, OffTarget, Source>(
pub fn render_workspace<'frame, R, Target, OffTarget, Source>(
gpu: Option<&DrmNode>,
renderer: &mut R,
target: Target,
@ -190,7 +195,6 @@ where
+ Offscreen<OffTarget>
+ Blit<Source>
+ AsGlowRenderer,
<R as Renderer>::Frame: AsGles2Frame,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
CosmicElement<R>: RenderElement<R>,
@ -199,6 +203,15 @@ where
{
if let Some(ref mut fps) = fps {
fps.start();
#[cfg(feature = "debug")]
if screencopy.is_some() {
if let Some(rd) = fps.rd.as_mut() {
rd.start_frame_capture(
renderer.glow_renderer().egl_context().get_context_handle(),
std::ptr::null(),
);
}
}
}
let workspace = state.shell.space_for_handle(&handle).ok_or(OutputNoMode)?;
@ -245,7 +258,7 @@ where
elements.extend(
workspace
.render_output::<R>(output)
.render_output::<R>(renderer, output)
.map_err(|_| OutputNoMode)?
.into_iter()
.map(Into::into),
@ -307,6 +320,13 @@ where
}
if let Some(fps) = fps.as_mut() {
fps.screencopy();
#[cfg(feature = "debug")]
if let Some(rd) = fps.rd.as_mut() {
rd.end_frame_capture(
renderer.glow_renderer().egl_context().get_context_handle(),
std::ptr::null(),
);
}
}
}

5
src/backend/winit.rs
View file

@ -71,10 +71,13 @@ impl WinitState {
Some(&mut self.fps),
) {
Ok((damage, states)) => {
self.screencopy.clear();
self.backend
.bind()
.with_context(|| "Failed to bind display")?;
self.backend
.submit(damage.as_deref())
.with_context(|| "Failed to submit buffer for display")?;
self.screencopy.clear();
#[cfg(feature = "debug")]
self.fps.displayed();
state.send_frames(&self.output, &states);

1
src/debug.rs
View file

@ -185,6 +185,5 @@ pub fn fps_ui(
area,
scale,
0.8,
state.clock.now().into(),
)
}

9
src/input/mod.rs
View file

@ -535,6 +535,15 @@ impl State {
#[cfg(feature = "debug")]
Action::Debug => {
self.common.egui.active = !self.common.egui.active;
for mapped in self
.common
.shell
.workspaces
.spaces()
.flat_map(|w| w.mapped())
{
mapped.set_debug(self.common.egui.active);
}
}
#[cfg(not(feature = "debug"))]
Action::Debug => {

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

@ -1,8 +1,5 @@
use crate::{
backend::render::{
element::{AsGles2Frame, AsGlowRenderer, CosmicElement},
GlMultiRenderer,
},
backend::render::{element::AsGlowRenderer, GlMultiFrame, GlMultiRenderer},
state::State,
utils::prelude::SeatExt,
};
@ -11,13 +8,8 @@ use smithay::{
backend::{
input::KeyState,
renderer::{
element::{
texture::TextureRenderElement, AsRenderElements, Element, RenderElement,
UnderlyingStorage,
},
gles2::Gles2Texture,
element::{AsRenderElements, Element, RenderElement, UnderlyingStorage},
glow::GlowRenderer,
multigpu::Error as MultiError,
ImportAll, Renderer,
},
},
@ -53,9 +45,16 @@ pub mod window;
pub use self::window::CosmicWindow;
#[cfg(feature = "debug")]
use smithay::wayland::shell::xdg::XdgToplevelSurfaceData;
use crate::backend::render::element::AsGlowFrame;
#[cfg(feature = "debug")]
use smithay_egui::EguiState;
use egui::plot::{Corner, Legend, Plot, PlotPoints, Polygon};
#[cfg(feature = "debug")]
use smithay::{
backend::renderer::{
element::texture::TextureRenderElement, gles2::Gles2Texture, multigpu::Error as MultiError,
},
wayland::shell::xdg::XdgToplevelSurfaceData,
};
use super::{focus::FocusDirection, layout::floating::ResizeState};
@ -80,7 +79,7 @@ pub struct CosmicMapped {
pub(super) resize_state: Arc<Mutex<Option<ResizeState>>>,
#[cfg(feature = "debug")]
debug: Arc<Mutex<smithay_egui::EguiState>>,
debug: Arc<Mutex<Option<smithay_egui::EguiState>>>,
}
impl fmt::Debug for CosmicMapped {
@ -554,6 +553,19 @@ impl CosmicMapped {
// Kind::X11?
};
}
#[cfg(feature = "debug")]
pub fn set_debug(&self, flag: bool) {
let mut debug = self.debug.lock().unwrap();
if flag {
*debug = Some(smithay_egui::EguiState::new(Rectangle::from_loc_and_size(
(10, 10),
(100, 100),
)));
} else {
debug.take();
}
}
}
impl IsAlive for CosmicMapped {
@ -722,9 +734,7 @@ impl From<CosmicWindow> for CosmicMapped {
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)),
))),
debug: Arc::new(Mutex::new(None)),
}
}
}
@ -738,9 +748,7 @@ impl From<CosmicStack> for CosmicMapped {
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)),
))),
debug: Arc::new(Mutex::new(None)),
}
}
}
@ -749,7 +757,6 @@ 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>),
@ -761,7 +768,6 @@ 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 {
@ -841,10 +847,9 @@ where
}
impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
fn draw(
fn draw<'frame>(
&self,
renderer: &mut GlowRenderer,
frame: &mut <GlowRenderer as Renderer>::Frame,
frame: &mut <GlowRenderer as Renderer>::Frame<'frame>,
location: Point<i32, Physical>,
scale: Scale<f64>,
damage: &[Rectangle<i32, Physical>],
@ -852,14 +857,14 @@ impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicMappedRenderElement::Stack(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
elem.draw(frame, location, scale, damage, log)
}
CosmicMappedRenderElement::Window(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
elem.draw(frame, location, scale, damage, log)
}
#[cfg(feature = "debug")]
CosmicMappedRenderElement::Egui(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
RenderElement::<GlowRenderer>::draw(elem, frame, location, scale, damage, log)
}
}
}
@ -878,10 +883,9 @@ impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
}
impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicMappedRenderElement<GlMultiRenderer<'a>> {
fn draw(
fn draw<'frame>(
&self,
renderer: &mut GlMultiRenderer<'a>,
frame: &mut <GlMultiRenderer<'a> as Renderer>::Frame,
frame: &mut GlMultiFrame<'a, 'frame>,
location: Point<i32, Physical>,
scale: Scale<f64>,
damage: &[Rectangle<i32, Physical>],
@ -889,16 +893,15 @@ impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicMappedRenderElement<GlMult
) -> Result<(), <GlMultiRenderer<'_> as Renderer>::Error> {
match self {
CosmicMappedRenderElement::Stack(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
elem.draw(frame, location, scale, damage, log)
}
CosmicMappedRenderElement::Window(elem) => {
elem.draw(renderer, frame, location, scale, damage, log)
elem.draw(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)
let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(elem, glow_frame, location, scale, damage, log)
.map_err(|err| MultiError::Render(err))
}
}
@ -929,7 +932,6 @@ 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 {
@ -940,7 +942,6 @@ impl<R> From<window::CosmicWindowRenderElement<R>> for CosmicMappedRenderElement
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 {
@ -952,7 +953,6 @@ 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 {
@ -964,137 +964,203 @@ impl<R> AsRenderElements<R> for CosmicMapped
where
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>>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
) -> Vec<C> {
let mut elements = match &self.element {
CosmicMappedInternal::Stack(s) => AsRenderElements::<R>::render_elements::<
CosmicMappedRenderElement<R>,
>(s, location, scale),
CosmicMappedInternal::Window(w) => AsRenderElements::<R>::render_elements::<
CosmicMappedRenderElement<R>,
>(w, location, scale),
_ => Vec::new(),
};
/*
#[cfg(feature = "debug")]
if !elements.is_empty() {
let mut elements = if let Some(debug) = self.debug.lock().unwrap().as_mut() {
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 window_geo = window.geometry();
let (app_id, title, min_size, max_size, size, states) =
with_states(&window.toplevel().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)
};
let area = Rectangle::<i32, Logical>::from_loc_and_size(
location.to_f64().to_logical(scale).to_i32_round(),
self.bbox().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 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(title.as_deref().unwrap_or("<None>"));
ui.horizontal(|ui| {
ui.label("App ID: ");
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)));
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 = ((max_size.w + 20) / 2, (max_size.h + 20) / 2);
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)),
);
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)));
}
if let Some(size) = size {
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)),
);
}
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)));
})
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)),
);
})
})
});
},
renderer,
glow_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,
scale.x,
0.8,
) {
Ok(element) => elements.push(element),
Err(err) => slog_scope::debug!("Error rendering debug overlay: {}", err),
};
}
*/
Ok(element) => vec![element.into()],
Err(err) => {
slog_scope::debug!("Error rendering debug overlay: {}", err);
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))
}
CosmicMappedInternal::Window(w) => {
elements.extend(AsRenderElements::<R>::render_elements::<
CosmicMappedRenderElement<R>,
>(w, renderer, location, scale))
}
_ => {}
};
elements.into_iter().map(C::from).collect()
}

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

@ -363,7 +363,7 @@ impl PointerTarget<State> for CosmicStack {
render_elements! {
pub CosmicStackRenderElement<R> where R: ImportAll;
Window=WaylandSurfaceRenderElement,
Window=WaylandSurfaceRenderElement<R>,
}
impl<R> AsRenderElements<R> for CosmicStack
@ -374,11 +374,13 @@ where
type RenderElement = CosmicStackRenderElement<R>;
fn render_elements<C: From<Self::RenderElement>>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
) -> Vec<C> {
AsRenderElements::<R>::render_elements::<CosmicStackRenderElement<R>>(
&self.windows.lock().unwrap()[self.active.load(Ordering::SeqCst)],
renderer,
location,
scale,
)

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

@ -236,7 +236,7 @@ impl PointerTarget<State> for CosmicWindow {
render_elements! {
pub CosmicWindowRenderElement<R> where R: ImportAll;
Window=WaylandSurfaceRenderElement,
Window=WaylandSurfaceRenderElement<R>,
}
impl<R> AsRenderElements<R> for CosmicWindow
@ -247,11 +247,13 @@ where
type RenderElement = CosmicWindowRenderElement<R>;
fn render_elements<C: From<Self::RenderElement>>(
&self,
renderer: &mut R,
location: Point<i32, Physical>,
scale: Scale<f64>,
) -> Vec<C> {
AsRenderElements::<R>::render_elements::<CosmicWindowRenderElement<R>>(
&self.window,
renderer,
location,
scale,
)

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

@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::{
backend::render::element::{AsGles2Frame, AsGlowRenderer},
backend::render::element::AsGlowRenderer,
shell::{
element::{CosmicMapped, CosmicMappedRenderElement},
focus::target::{KeyboardFocusTarget, PointerFocusTarget},
@ -36,11 +36,10 @@ pub struct MoveGrabState {
}
impl MoveGrabState {
pub fn render<I, R>(&self, seat: &Seat<State>, output: &Output) -> Vec<I>
pub fn render<I, R>(&self, renderer: &mut R, seat: &Seat<State>, output: &Output) -> Vec<I>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
I: From<CosmicMappedRenderElement<R>>,
{
@ -57,6 +56,7 @@ impl MoveGrabState {
let scale = output.current_scale().fractional_scale().into();
AsRenderElements::<R>::render_elements::<I>(
&self.window,
renderer,
(location.to_i32_round() - output.geometry().loc - self.window.geometry().loc)
.to_physical_precise_round(scale),
scale,

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

@ -10,7 +10,7 @@ use smithay::{
use std::collections::HashMap;
use crate::{
backend::render::element::{AsGles2Frame, AsGlowRenderer},
backend::render::element::AsGlowRenderer,
shell::{
element::{CosmicMapped, CosmicMappedRenderElement},
grabs::ResizeEdge,
@ -294,18 +294,18 @@ impl FloatingLayout {
pub fn render_output<R>(
&self,
renderer: &mut R,
output: &Output,
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
where
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))
.render_elements_for_region(renderer, &output_geo, output_scale))
}
}

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

@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
use crate::{
backend::render::element::{AsGles2Frame, AsGlowRenderer},
backend::render::element::AsGlowRenderer,
shell::{
element::{CosmicMapped, CosmicMappedRenderElement},
focus::{
@ -1236,12 +1236,12 @@ impl TilingLayout {
pub fn render_output<R>(
&self,
renderer: &mut R,
output: &Output,
) -> Result<Vec<CosmicMappedRenderElement<R>>, OutputNotMapped>
where
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();
@ -1276,6 +1276,7 @@ impl TilingLayout {
.flat_map(|(mapped, loc)| {
AsRenderElements::<R>::render_elements::<CosmicMappedRenderElement<R>>(
mapped,
renderer,
loc.to_physical_precise_round(output_scale)
- mapped
.geometry()

41
src/shell/mod.rs
View file

@ -1,5 +1,5 @@
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, cell::RefCell};
use std::{cell::RefCell, collections::HashMap};
use cosmic_protocols::workspace::v1::server::zcosmic_workspace_handle_v1::State as WState;
use smithay::{
@ -20,7 +20,7 @@ use smithay::{
};
use crate::{
config::{Config, WorkspaceMode as ConfigMode, OutputConfig},
config::{Config, OutputConfig, WorkspaceMode as ConfigMode},
utils::prelude::*,
wayland::protocols::{
toplevel_info::ToplevelInfoState,
@ -459,13 +459,16 @@ impl Shell {
// TODO: Restore any window positions from previous outputs ???
state.add_group_output(&set.group, output);
for workspace in &mut set.workspaces {
workspace.map_output(output, output.user_data()
.get::<RefCell<OutputConfig>>()
.unwrap()
.borrow()
.position
.into()
);
workspace.map_output(
output,
output
.user_data()
.get::<RefCell<OutputConfig>>()
.unwrap()
.borrow()
.position
.into(),
);
}
}
}
@ -538,12 +541,16 @@ impl Shell {
if let WorkspaceMode::Global(set) = &mut self.workspaces {
for workspace in &mut set.workspaces {
for output in self.outputs.iter() {
workspace.map_output(output, output.user_data()
.get::<RefCell<OutputConfig>>()
.unwrap()
.borrow()
.position
.into());
workspace.map_output(
output,
output
.user_data()
.get::<RefCell<OutputConfig>>()
.unwrap()
.borrow()
.position
.into(),
);
}
}
}
@ -966,6 +973,10 @@ impl Shell {
.toplevel_enter_workspace(&window, &workspace.handle);
let mapped = CosmicMapped::from(CosmicWindow::from(window.clone()));
#[cfg(feature = "debug")]
{
mapped.set_debug(state.common.egui.active);
}
if layout::should_be_floating(&window) || state.common.shell.floating_default {
workspace.floating_layer.map(mapped.clone(), &seat, None);
} else {

39
src/shell/workspace.rs
View file

@ -1,5 +1,5 @@
use crate::{
backend::render::element::{AsGles2Frame, AsGlowRenderer},
backend::render::element::AsGlowRenderer,
shell::layout::{
floating::{FloatingLayout, MoveSurfaceGrab},
tiling::TilingLayout,
@ -418,12 +418,12 @@ impl Workspace {
pub fn render_output<R>(
&self,
renderer: &mut R,
output: &Output,
) -> Result<Vec<WorkspaceRenderElement<R>>, OutputNotMapped>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
let mut render_elements = Vec::new();
@ -446,6 +446,7 @@ impl Workspace {
.flat_map(|(loc, surface)| {
AsRenderElements::<R>::render_elements::<WorkspaceRenderElement<R>>(
surface,
renderer,
loc.to_physical_precise_round(output_scale),
Scale::from(output_scale),
)
@ -455,7 +456,9 @@ impl Workspace {
// fullscreen window
render_elements.extend(AsRenderElements::<R>::render_elements::<
WorkspaceRenderElement<R>,
>(fullscreen, (0, 0).into(), output_scale.into()));
>(
fullscreen, renderer, (0, 0).into(), output_scale.into()
));
} else {
// TODO: Handle modes like
// - keyboard window swapping
@ -479,6 +482,7 @@ impl Workspace {
.flat_map(|(loc, surface)| {
AsRenderElements::<R>::render_elements::<WorkspaceRenderElement<R>>(
surface,
renderer,
loc.to_physical_precise_round(output_scale),
Scale::from(output_scale),
)
@ -491,7 +495,7 @@ impl Workspace {
// floating surfaces
render_elements.extend(
self.floating_layer
.render_output::<R>(output)?
.render_output::<R>(renderer, output)?
.into_iter()
.map(WorkspaceRenderElement::from),
);
@ -499,7 +503,7 @@ impl Workspace {
//tiling surfaces
render_elements.extend(
self.tiling_layer
.render_output::<R>(output)?
.render_output::<R>(renderer, output)?
.into_iter()
.map(WorkspaceRenderElement::from),
);
@ -517,6 +521,7 @@ impl Workspace {
.flat_map(|(loc, surface)| {
AsRenderElements::<R>::render_elements::<WorkspaceRenderElement<R>>(
surface,
renderer,
loc.to_physical_precise_round(output_scale),
Scale::from(output_scale),
)
@ -545,9 +550,8 @@ pub enum WorkspaceRenderElement<R>
where
R: Renderer + ImportAll + AsGlowRenderer,
<R as Renderer>::TextureId: 'static,
<R as Renderer>::Frame: AsGles2Frame,
{
Wayland(WaylandSurfaceRenderElement),
Wayland(WaylandSurfaceRenderElement<R>),
Window(CosmicMappedRenderElement<R>),
}
@ -555,7 +559,6 @@ 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 {
@ -622,25 +625,19 @@ 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(
fn draw<'frame>(
&self,
renderer: &mut R,
frame: &mut <R as Renderer>::Frame,
frame: &mut <R as Renderer>::Frame<'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)
}
WorkspaceRenderElement::Wayland(elem) => elem.draw(frame, location, scale, damage, log),
WorkspaceRenderElement::Window(elem) => elem.draw(frame, location, scale, damage, log),
}
}
@ -655,14 +652,13 @@ where
}
}
impl<R> From<WaylandSurfaceRenderElement> for WorkspaceRenderElement<R>
impl<R> From<WaylandSurfaceRenderElement<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: WaylandSurfaceRenderElement) -> Self {
fn from(elem: WaylandSurfaceRenderElement<R>) -> Self {
WorkspaceRenderElement::Wayland(elem)
}
}
@ -671,7 +667,6 @@ 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 {

4
src/state.rs
View file

@ -433,6 +433,8 @@ pub struct Egui {
}
pub struct Fps {
#[cfg(feature = "debug")]
pub rd: Option<renderdoc::RenderDoc<renderdoc::V110>>,
#[cfg(feature = "debug")]
pub state: smithay_egui::EguiState,
pending_frame: Option<PendingFrame>,
@ -638,6 +640,8 @@ impl Fps {
Fps {
#[cfg(feature = "debug")]
state,
#[cfg(feature = "debug")]
rd: renderdoc::RenderDoc::new().ok(),
pending_frame: None,
frames: VecDeque::with_capacity(Fps::WINDOW_SIZE + 1),
}

14
src/wayland/handlers/screencopy.rs
View file

@ -725,7 +725,7 @@ pub fn render_workspace_to_buffer(
smithay::render_elements! {
pub WindowCaptureElement<R> where R: ImportAll;
WaylandElement=WaylandSurfaceRenderElement,
WaylandElement=WaylandSurfaceRenderElement<R>,
CursorElement=cursor::CursorRenderElement<R>,
}
@ -769,6 +769,7 @@ pub fn render_window_to_buffer(
WindowCaptureElement<GlowRenderer>,
>(
window,
renderer,
(-geometry.loc.x, -geometry.loc.y).into(),
Scale::from(1.0),
);
@ -810,9 +811,14 @@ pub fn render_window_to_buffer(
if let Some(wl_surface) = get_dnd_icon(seat) {
elements.extend(
cursor::draw_dnd_icon(&wl_surface, location.to_i32_round(), 1.0)
.into_iter()
.map(WindowCaptureElement::from),
cursor::draw_dnd_icon(
renderer,
&wl_surface,
location.to_i32_round(),
1.0,
)
.into_iter()
.map(WindowCaptureElement::from),
);
}
}