Miroirs/smithay
1
0
Fork 0
mirror of https://github.com/Smithay/smithay.git synced 2024-09-28 03:21:14 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

anvil: Fixup x11 backend

Browse source
This commit is contained in:
Victoria Brekenfeld 2022-08-25 14:24:41 +00:00
parent bc190270e3
commit cd89666c1c
3 changed files with 100 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

61
anvil/Cargo.toml
View file

@ -1,48 +1,59 @@
[package]
name = "anvil"
version = "0.0.1"
authors = ["Victor Berger <victor.berger@m4x.org>", "Drakulix (Victoria Brekenfeld)"]
license = "MIT"
publish = false
edition = "2018"
license = "MIT"
name = "anvil"
publish = false
version = "0.0.1"
[dependencies]
bitflags = "1.2.1"
thiserror = "1"
xcursor = { version = "0.3.3", optional = true }
image = { version = "0.24.0", default-features = false, optional = true }
fps_ticker = { version = "1.0.0", optional = true }
fps_ticker = {version = "1.0.0", optional = true}
image = {version = "0.24.0", default-features = false, optional = true}
rand = "0.8"
slog = { version = "2.1.1" }
slog-term = "2.8"
slog = {version = "2.1.1"}
slog-async = "2.2"
slog-stdlog = "4.1.0"
slog-scope = "4.4.0"
slog-stdlog = "4.1.0"
slog-term = "2.8"
thiserror = "1"
xcursor = {version = "0.3.3", optional = true}
xkbcommon = "0.5.0"
[dependencies.smithay]
path = ".."
default-features = false
features = [ "desktop", "wayland_frontend", "slog-stdlog" ]
features = ["desktop", "wayland_frontend", "slog-stdlog"]
path = ".."
[dependencies.x11rb]
default-features = false
features = ["composite"]
optional = true
version = "0.10.0"
default-features = false
features = [ "composite" ]
[build-dependencies]
gl_generator = "0.14"
[features]
default = [ "egl", "winit", "logind", "xwayland" ] #, "x11", "udev"
egl = [ "smithay/use_system_lib", "smithay/backend_egl" ]
winit = [ "smithay/backend_winit" ]
udev = [ "smithay/backend_libinput", "smithay/backend_udev", "smithay/backend_drm", "smithay/backend_gbm", "smithay/backend_egl", "smithay/backend_session", "image", "smithay/renderer_gl", "smithay/renderer_multi", "xcursor" ]
logind = [ "smithay/backend_session_logind" ]
elogind = ["logind", "smithay/backend_session_elogind" ]
libseat = ["smithay/backend_session_libseat" ]
xwayland = [ "smithay/xwayland", "x11rb", "smithay/x11rb_event_source" ]
x11 = [ "smithay/backend_x11", "x11rb", "egl", "smithay/renderer_gl" ]
debug = [ "fps_ticker", "image/png" ]
debug = ["fps_ticker", "image/png"]
default = ["egl", "winit", "x11", "logind", "xwayland"] #, "udev"
egl = ["smithay/use_system_lib", "smithay/backend_egl"]
elogind = ["logind", "smithay/backend_session_elogind"]
libseat = ["smithay/backend_session_libseat"]
logind = ["smithay/backend_session_logind"]
test_all_features = ["default", "debug"]
udev = [
"smithay/backend_libinput",
"smithay/backend_udev",
"smithay/backend_drm",
"smithay/backend_gbm",
"smithay/backend_egl",
"smithay/backend_session",
"image",
"smithay/renderer_gl",
"smithay/renderer_multi",
"xcursor",
]
winit = ["smithay/backend_winit"]
x11 = ["smithay/backend_x11", "x11rb", "egl", "smithay/renderer_gl"]
xwayland = ["smithay/xwayland", "x11rb", "smithay/x11rb_event_source"]

24
anvil/src/winit.rs
View file

@ -1,4 +1,7 @@
use std::{sync::atomic::Ordering, time::Duration};
use std::{
sync::{atomic::Ordering, Mutex},
time::Duration,
};
use slog::Logger;
#[cfg(feature = "debug")]
@ -22,7 +25,7 @@ use smithay::{
winit::{self, WinitEvent, WinitGraphicsBackend},
SwapBuffersError,
},
input::pointer::CursorImageStatus,
input::pointer::{CursorImageAttributes, CursorImageStatus},
output::{Mode, Output, PhysicalProperties, Subpixel},
reexports::{
calloop::EventLoop,
@ -32,7 +35,7 @@ use smithay::{
},
},
utils::{IsAlive, Point, Scale},
wayland::input_method::InputMethodSeat,
wayland::{compositor, input_method::InputMethodSeat},
};
use crate::state::{AnvilState, Backend, CalloopData};
@ -263,10 +266,23 @@ pub fn run_winit(log: Logger) {
// draw the dnd icon if any
if let Some(surface) = dnd_icon {
if surface.alive() {
let cursor_hotspot = if let CursorImageStatus::Surface(ref surface) = *cursor_guard {
compositor::with_states(surface, |states| {
states
.data_map
.get::<Mutex<CursorImageAttributes>>()
.unwrap()
.lock()
.unwrap()
.hotspot
})
} else {
(0, 0).into()
};
elements.extend(AsRenderElements::<Gles2Renderer>::render_elements(
&smithay::desktop::space::SurfaceTree::from_surface(
surface,
cursor_pos.to_i32_round(),
cursor_pos.to_i32_round() - cursor_hotspot,
),
cursor_pos_scaled,
scale,

90
anvil/src/x11.rs
View file

@ -5,14 +5,12 @@ use std::{
use crate::{
drawing::*,
render,
render::*,
state::{AnvilState, Backend, CalloopData},
};
use slog::Logger;
#[cfg(not(feature = "debug"))]
use smithay::desktop::space::SpaceRenderElements;
#[cfg(feature = "debug")]
use smithay::{backend::renderer::ImportMem, render_elements};
use smithay::backend::renderer::ImportMem;
#[cfg(feature = "egl")]
use smithay::{
backend::{
@ -25,15 +23,9 @@ use smithay::{
use smithay::{
backend::{
egl::{EGLContext, EGLDisplay},
renderer::{
damage::DamageTrackedRenderer,
element::{surface::WaylandSurfaceRenderElement, texture::TextureRenderElement},
gles2::Gles2Renderer,
Bind, Renderer,
},
renderer::{damage::DamageTrackedRenderer, element::AsRenderElements, gles2::Gles2Renderer, Bind},
x11::{WindowBuilder, X11Backend, X11Event, X11Surface},
},
desktop::space::SurfaceTree,
input::pointer::{CursorImageAttributes, CursorImageStatus},
output::{Mode, Output, PhysicalProperties, Subpixel},
reexports::{
@ -41,8 +33,8 @@ use smithay::{
gbm,
wayland_server::{protocol::wl_surface, Display},
},
utils::IsAlive,
wayland::compositor,
utils::{IsAlive, Point, Scale},
wayland::{compositor, input_method::InputMethodSeat},
};
pub const OUTPUT_NAME: &str = "x11";
@ -89,23 +81,6 @@ impl Backend for X11Data {
fn early_import(&mut self, _surface: &wl_surface::WlSurface) {}
}
#[cfg(feature = "debug")]
render_elements! {
pub CustomRenderElements<'a, R>;
Surface=WaylandSurfaceRenderElement,
Texture=TextureRenderElement<<R as Renderer>::TextureId>,
Fps=&'a FpsElement<<R as Renderer>::TextureId>
}
smithay::space_elements! {
CustomSpaceElements<'a, R>[
WaylandSurfaceRenderElement,
TextureRenderElement<<R as Renderer>::TextureId>,
];
Pointer=&'a PointerElement<<R as Renderer>::TextureId>,
SurfaceTree=SurfaceTree,
}
pub fn run_x11(log: Logger) {
let mut event_loop = EventLoop::try_new().unwrap();
let mut display = Display::new().unwrap();
@ -263,7 +238,6 @@ pub fn run_x11(log: Logger) {
let backend_data = &mut state.backend_data;
let cursor_visible: bool;
// We need to borrow everything we want to refer to inside the renderer callback otherwise rustc is unhappy.
let (x, y) = state.pointer_location.into();
let cursor_status = &state.cursor_status;
#[cfg(feature = "debug")]
let fps = backend_data.fps.avg().round() as u32;
@ -277,7 +251,7 @@ pub fn run_x11(log: Logger) {
}
let mut cursor_guard = cursor_status.lock().unwrap();
let mut custom_space_elements: Vec<CustomSpaceElements<'_, _>> = Vec::new();
let mut elements: Vec<CustomRenderElements<Gles2Renderer>> = Vec::new();
// draw the cursor as relevant
// reset the cursor if the surface is no longer alive
@ -295,9 +269,28 @@ pub fn run_x11(log: Logger) {
cursor_visible = true;
}
pointer_element.set_position((x as i32, y as i32));
let scale = Scale::from(output.current_scale().fractional_scale());
let cursor_pos = state.pointer_location;
let cursor_pos_scaled = state.pointer_location.to_physical(scale).to_i32_round();
pointer_element.set_position(cursor_pos.to_i32_round());
pointer_element.set_status(cursor_guard.clone());
custom_space_elements.push(CustomSpaceElements::Pointer(&pointer_element));
elements.extend(pointer_element.render_elements(cursor_pos_scaled, scale));
// draw input method surface if any
let input_method = state.seat.input_method().unwrap();
let rectangle = input_method.coordinates();
let position = Point::from((
rectangle.loc.x + rectangle.size.w,
rectangle.loc.y + rectangle.size.h,
));
input_method.with_surface(|surface| {
elements.extend(AsRenderElements::<Gles2Renderer>::render_elements(
&smithay::desktop::space::SurfaceTree::from_surface(surface, position),
position.to_physical_precise_round(scale),
scale,
));
});
// draw the dnd icon if any
if let Some(surface) = state.dnd_icon.as_ref() {
@ -315,22 +308,25 @@ pub fn run_x11(log: Logger) {
} else {
(0, 0).into()
};
custom_space_elements.push(CustomSpaceElements::SurfaceTree(
smithay::desktop::space::SurfaceTree::from_surface(
elements.extend(AsRenderElements::<Gles2Renderer>::render_elements(
&smithay::desktop::space::SurfaceTree::from_surface(
surface,
state.pointer_location.to_i32_round() - cursor_hotspot,
cursor_pos.to_i32_round() - cursor_hotspot,
),
cursor_pos_scaled,
scale,
));
}
}
#[cfg(feature = "debug")]
let render_res = render::render_output::<_, _, CustomRenderElements<'_, _>>(
elements.push(CustomRenderElements::Fps(fps_element.clone()));
#[cfg(feature = "debug")]
let render_res = render_output(
&output,
&state.space,
&*custom_space_elements,
&[CustomRenderElements::Fps(&fps_element)],
&elements,
&mut backend_data.renderer,
&mut backend_data.damage_tracked_renderer,
age.into(),
@ -338,11 +334,10 @@ pub fn run_x11(log: Logger) {
);
#[cfg(not(feature = "debug"))]
let render_res = render::render_output::<_, _, SpaceRenderElements<_>>(
let render_res = render_output(
&output,
&state.space,
&*custom_space_elements,
&[],
&elements,
&mut backend_data.renderer,
&mut backend_data.damage_tracked_renderer,
age.into(),
@ -372,7 +367,10 @@ pub fn run_x11(log: Logger) {
}
// Send frame events so that client start drawing their next frame
state.space.send_frames(start_time.elapsed().as_millis() as u32);
state
.space
.elements()
.for_each(|window| window.send_frame(start_time.elapsed().as_millis() as u32));
let mut calloop_data = CalloopData { state, display };
let result = event_loop.dispatch(Some(Duration::from_millis(16)), &mut calloop_data);
@ -381,7 +379,7 @@ pub fn run_x11(log: Logger) {
if result.is_err() {
state.running.store(false, Ordering::SeqCst);
} else {
state.space.refresh(&display.handle());
state.space.refresh();
state.popups.cleanup();
display.flush_clients().unwrap();
}