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: Drop CalloopData

Browse source
This commit is contained in:
Victoria Brekenfeld 2024-03-21 21:02:30 +01:00 committed by Victoria Brekenfeld
parent bfa56fc54b
commit 47a8d5b5e5
10 changed files with 102 additions and 174 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
anvil/src/input_handler.rs
View file

@ -20,7 +20,7 @@ use smithay::{
output::Scale,
reexports::{
wayland_protocols::xdg::decoration::zv1::server::zxdg_toplevel_decoration_v1,
wayland_server::{protocol::wl_pointer, DisplayHandle},
wayland_server::protocol::wl_pointer,
},
utils::{Logical, Point, Serial, Transform, SERIAL_COUNTER as SCOUNTER},
wayland::{
@ -60,6 +60,7 @@ use smithay::{
},
touch::{DownEvent, UpEvent},
},
reexports::wayland_server::DisplayHandle,
wayland::{
pointer_constraints::{with_pointer_constraint, PointerConstraint},
seat::WaylandFocus,
@ -408,7 +409,7 @@ impl<BackendData: Backend> AnvilState<BackendData> {
under
}
fn on_pointer_axis<B: InputBackend>(&mut self, _dh: &DisplayHandle, evt: B::PointerAxisEvent) {
fn on_pointer_axis<B: InputBackend>(&mut self, evt: B::PointerAxisEvent) {
let horizontal_amount = evt
.amount(input::Axis::Horizontal)
.unwrap_or_else(|| evt.amount_v120(input::Axis::Horizontal).unwrap_or(0.0) * 15.0 / 120.);
@ -451,12 +452,7 @@ impl<BackendData: Backend> AnvilState<BackendData> {
#[cfg(any(feature = "winit", feature = "x11"))]
impl<Backend: crate::state::Backend> AnvilState<Backend> {
pub fn process_input_event_windowed<B: InputBackend>(
&mut self,
dh: &DisplayHandle,
event: InputEvent<B>,
output_name: &str,
) {
pub fn process_input_event_windowed<B: InputBackend>(&mut self, event: InputEvent<B>, output_name: &str) {
match event {
InputEvent::Keyboard { event } => match self.keyboard_key_to_action::<B>(event) {
KeyAction::ScaleUp => {
@ -538,17 +534,16 @@ impl<Backend: crate::state::Backend> AnvilState<Backend> {
.find(|o| o.name() == output_name)
.unwrap()
.clone();
self.on_pointer_move_absolute_windowed::<B>(dh, event, &output)
self.on_pointer_move_absolute_windowed::<B>(event, &output)
}
InputEvent::PointerButton { event } => self.on_pointer_button::<B>(event),
InputEvent::PointerAxis { event } => self.on_pointer_axis::<B>(dh, event),
InputEvent::PointerAxis { event } => self.on_pointer_axis::<B>(event),
_ => (), // other events are not handled in anvil (yet)
}
}
fn on_pointer_move_absolute_windowed<B: InputBackend>(
&mut self,
_dh: &DisplayHandle,
evt: B::PointerMotionAbsoluteEvent,
output: &Output,
) {
@ -745,7 +740,7 @@ impl AnvilState<UdevData> {
InputEvent::PointerMotion { event, .. } => self.on_pointer_move::<B>(dh, event),
InputEvent::PointerMotionAbsolute { event, .. } => self.on_pointer_move_absolute::<B>(dh, event),
InputEvent::PointerButton { event, .. } => self.on_pointer_button::<B>(event),
InputEvent::PointerAxis { event, .. } => self.on_pointer_axis::<B>(dh, event),
InputEvent::PointerAxis { event, .. } => self.on_pointer_axis::<B>(event),
InputEvent::TabletToolAxis { event, .. } => self.on_tablet_tool_axis::<B>(event),
InputEvent::TabletToolProximity { event, .. } => self.on_tablet_tool_proximity::<B>(dh, event),
InputEvent::TabletToolTip { event, .. } => self.on_tablet_tool_tip::<B>(event),

2
anvil/src/lib.rs
View file

@ -21,4 +21,4 @@ pub mod winit;
#[cfg(feature = "x11")]
pub mod x11;
pub use state::{AnvilState, CalloopData, ClientState};
pub use state::{AnvilState, ClientState};

9
anvil/src/shell/mod.rs
View file

@ -35,8 +35,6 @@ use smithay::{
},
};
#[cfg(feature = "xwayland")]
use crate::CalloopData;
use crate::{
state::{AnvilState, Backend},
ClientState,
@ -124,9 +122,8 @@ impl<BackendData: Backend> CompositorHandler for AnvilState<BackendData> {
if let Ok((blocker, source)) = dmabuf.generate_blocker(Interest::READ) {
let client = surface.client().unwrap();
let res = state.handle.insert_source(source, move |_, _, data| {
data.state
.client_compositor_state(&client)
.blocker_cleared(&mut data.state, &data.display_handle);
let dh = data.display_handle.clone();
data.client_compositor_state(&client).blocker_cleared(data, &dh);
Ok(())
});
if res.is_ok() {
@ -139,7 +136,7 @@ impl<BackendData: Backend> CompositorHandler for AnvilState<BackendData> {
fn commit(&mut self, surface: &WlSurface) {
#[cfg(feature = "xwayland")]
X11Wm::commit_hook::<CalloopData<BackendData>>(surface);
X11Wm::commit_hook::<AnvilState<BackendData>>(surface);
on_commit_buffer_handler::<Self>(surface);
self.backend_data.early_import(surface);

12
anvil/src/shell/ssd.rs
View file

@ -78,7 +78,7 @@ impl HeaderBar {
let surface = w.clone();
state
.handle
.insert_idle(move |data| data.state.maximize_request_x11(&surface));
.insert_idle(move |data| data.maximize_request_x11(&surface));
}
};
}
@ -89,14 +89,14 @@ impl HeaderBar {
let toplevel = w.clone();
state
.handle
.insert_idle(move |data| data.state.move_request_xdg(&toplevel, &seat, serial));
.insert_idle(move |data| data.move_request_xdg(&toplevel, &seat, serial));
}
#[cfg(feature = "xwayland")]
WindowSurface::X11(w) => {
let window = w.clone();
state
.handle
.insert_idle(move |data| data.state.move_request_x11(&window));
.insert_idle(move |data| data.move_request_x11(&window));
}
};
}
@ -121,14 +121,14 @@ impl HeaderBar {
let toplevel = w.clone();
state
.handle
.insert_idle(move |data| data.state.move_request_xdg(&toplevel, &seat, serial));
.insert_idle(move |data| data.move_request_xdg(&toplevel, &seat, serial));
}
#[cfg(feature = "xwayland")]
WindowSurface::X11(w) => {
let window = w.clone();
state
.handle
.insert_idle(move |data| data.state.move_request_x11(&window));
.insert_idle(move |data| data.move_request_x11(&window));
}
};
}
@ -161,7 +161,7 @@ impl HeaderBar {
let surface = w.clone();
state
.handle
.insert_idle(move |data| data.state.maximize_request_x11(&surface));
.insert_idle(move |data| data.maximize_request_x11(&surface));
}
};
}

71
anvil/src/shell/x11.rs
View file

@ -25,7 +25,7 @@ use smithay::{
};
use tracing::{error, trace};
use crate::{focus::KeyboardFocusTarget, state::Backend, AnvilState, CalloopData};
use crate::{focus::KeyboardFocusTarget, state::Backend, AnvilState};
use super::{
place_new_window, FullscreenSurface, PointerMoveSurfaceGrab, PointerResizeSurfaceGrab, ResizeData,
@ -44,9 +44,9 @@ impl OldGeometry {
}
}
impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
impl<BackendData: Backend> XwmHandler for AnvilState<BackendData> {
fn xwm_state(&mut self, _xwm: XwmId) -> &mut X11Wm {
self.state.xwm.as_mut().unwrap()
self.xwm.as_mut().unwrap()
}
fn new_window(&mut self, _xwm: XwmId, _window: X11Surface) {}
@ -55,13 +55,8 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
fn map_window_request(&mut self, _xwm: XwmId, window: X11Surface) {
window.set_mapped(true).unwrap();
let window = WindowElement(Window::new_x11_window(window));
place_new_window(
&mut self.state.space,
self.state.pointer.current_location(),
&window,
true,
);
let bbox = self.state.space.element_bbox(&window).unwrap();
place_new_window(&mut self.space, self.pointer.current_location(), &window, true);
let bbox = self.space.element_bbox(&window).unwrap();
let Some(xsurface) = window.0.x11_surface() else {
unreachable!()
};
@ -72,18 +67,17 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
fn mapped_override_redirect_window(&mut self, _xwm: XwmId, window: X11Surface) {
let location = window.geometry().loc;
let window = WindowElement(Window::new_x11_window(window));
self.state.space.map_element(window, location, true);
self.space.map_element(window, location, true);
}
fn unmapped_window(&mut self, _xwm: XwmId, window: X11Surface) {
let maybe = self
.state
.space
.elements()
.find(|e| matches!(e.0.x11_surface(), Some(w) if w == &window))
.cloned();
if let Some(elem) = maybe {
self.state.space.unmap_elem(&elem)
self.space.unmap_elem(&elem)
}
if !window.is_override_redirect() {
window.set_mapped(false).unwrap();
@ -121,7 +115,6 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
_above: Option<u32>,
) {
let Some(elem) = self
.state
.space
.elements()
.find(|e| matches!(e.0.x11_surface(), Some(w) if w == &window))
@ -129,18 +122,17 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
else {
return;
};
self.state.space.map_element(elem, geometry.loc, false);
self.space.map_element(elem, geometry.loc, false);
// TODO: We don't properly handle the order of override-redirect windows here,
// they are always mapped top and then never reordered.
}
fn maximize_request(&mut self, _xwm: XwmId, window: X11Surface) {
self.state.maximize_request_x11(&window);
self.maximize_request_x11(&window);
}
fn unmaximize_request(&mut self, _xwm: XwmId, window: X11Surface) {
let Some(elem) = self
.state
.space
.elements()
.find(|e| matches!(e.0.x11_surface(), Some(w) if w == &window))
@ -156,25 +148,24 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
.and_then(|data| data.restore())
{
window.configure(old_geo).unwrap();
self.state.space.map_element(elem, old_geo.loc, false);
self.space.map_element(elem, old_geo.loc, false);
}
}
fn fullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
if let Some(elem) = self
.state
.space
.elements()
.find(|e| matches!(e.0.x11_surface(), Some(w) if w == &window))
{
let outputs_for_window = self.state.space.outputs_for_element(elem);
let outputs_for_window = self.space.outputs_for_element(elem);
let output = outputs_for_window
.first()
// The window hasn't been mapped yet, use the primary output instead
.or_else(|| self.state.space.outputs().next())
.or_else(|| self.space.outputs().next())
// Assumes that at least one output exists
.expect("No outputs found");
let geometry = self.state.space.output_geometry(output).unwrap();
let geometry = self.space.output_geometry(output).unwrap();
window.set_fullscreen(true).unwrap();
elem.set_ssd(false);
@ -191,14 +182,13 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
fn unfullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
if let Some(elem) = self
.state
.space
.elements()
.find(|e| matches!(e.0.x11_surface(), Some(w) if w == &window))
{
window.set_fullscreen(false).unwrap();
elem.set_ssd(!window.is_decorated());
if let Some(output) = self.state.space.outputs().find(|o| {
if let Some(output) = self.space.outputs().find(|o| {
o.user_data()
.get::<FullscreenSurface>()
.and_then(|f| f.get())
@ -207,18 +197,17 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
}) {
trace!("Unfullscreening: {:?}", elem);
output.user_data().get::<FullscreenSurface>().unwrap().clear();
window.configure(self.state.space.element_bbox(elem)).unwrap();
self.state.backend_data.reset_buffers(output);
window.configure(self.space.element_bbox(elem)).unwrap();
self.backend_data.reset_buffers(output);
}
}
}
fn resize_request(&mut self, _xwm: XwmId, window: X11Surface, _button: u32, edges: X11ResizeEdge) {
// luckily anvil only supports one seat anyway...
let start_data = self.state.pointer.grab_start_data().unwrap();
let start_data = self.pointer.grab_start_data().unwrap();
let Some(element) = self
.state
.space
.elements()
.find(|e| matches!(e.0.x11_surface(), Some(w) if w == &window))
@ -227,7 +216,7 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
};
let geometry = element.geometry();
let loc = self.state.space.element_location(element).unwrap();
let loc = self.space.element_location(element).unwrap();
let (initial_window_location, initial_window_size) = (loc, geometry.size);
with_states(&element.wl_surface().unwrap(), move |states| {
@ -252,16 +241,16 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
last_window_size: initial_window_size,
};
let pointer = self.state.pointer.clone();
pointer.set_grab(&mut self.state, grab, SERIAL_COUNTER.next_serial(), Focus::Clear);
let pointer = self.pointer.clone();
pointer.set_grab(self, grab, SERIAL_COUNTER.next_serial(), Focus::Clear);
}
fn move_request(&mut self, _xwm: XwmId, window: X11Surface, _button: u32) {
self.state.move_request_x11(&window)
self.move_request_x11(&window)
}
fn allow_selection_access(&mut self, xwm: XwmId, _selection: SelectionTarget) -> bool {
if let Some(keyboard) = self.state.seat.get_keyboard() {
if let Some(keyboard) = self.seat.get_keyboard() {
// check that an X11 window is focused
if let Some(KeyboardFocusTarget::Window(w)) = keyboard.current_focus() {
if let Some(surface) = w.x11_surface() {
@ -277,12 +266,12 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
fn send_selection(&mut self, _xwm: XwmId, selection: SelectionTarget, mime_type: String, fd: OwnedFd) {
match selection {
SelectionTarget::Clipboard => {
if let Err(err) = request_data_device_client_selection(&self.state.seat, mime_type, fd) {
if let Err(err) = request_data_device_client_selection(&self.seat, mime_type, fd) {
error!(?err, "Failed to request current wayland clipboard for Xwayland",);
}
}
SelectionTarget::Primary => {
if let Err(err) = request_primary_client_selection(&self.state.seat, mime_type, fd) {
if let Err(err) = request_primary_client_selection(&self.seat, mime_type, fd) {
error!(
?err,
"Failed to request current wayland primary selection for Xwayland",
@ -297,10 +286,10 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
// TODO check, that focused windows is X11 window before doing this
match selection {
SelectionTarget::Clipboard => {
set_data_device_selection(&self.state.display_handle, &self.state.seat, mime_types, ())
set_data_device_selection(&self.display_handle, &self.seat, mime_types, ())
}
SelectionTarget::Primary => {
set_primary_selection(&self.state.display_handle, &self.state.seat, mime_types, ())
set_primary_selection(&self.display_handle, &self.seat, mime_types, ())
}
}
}
@ -308,13 +297,13 @@ impl<BackendData: Backend> XwmHandler for CalloopData<BackendData> {
fn cleared_selection(&mut self, _xwm: XwmId, selection: SelectionTarget) {
match selection {
SelectionTarget::Clipboard => {
if current_data_device_selection_userdata(&self.state.seat).is_some() {
clear_data_device_selection(&self.state.display_handle, &self.state.seat)
if current_data_device_selection_userdata(&self.seat).is_some() {
clear_data_device_selection(&self.display_handle, &self.seat)
}
}
SelectionTarget::Primary => {
if current_primary_selection_userdata(&self.state.seat).is_some() {
clear_primary_selection(&self.state.display_handle, &self.state.seat)
if current_primary_selection_userdata(&self.seat).is_some() {
clear_primary_selection(&self.display_handle, &self.seat)
}
}
}

19
anvil/src/state.rs
View file

@ -103,11 +103,6 @@ use smithay::{
xwayland::{X11Wm, XWayland, XWaylandEvent},
};
pub struct CalloopData<BackendData: Backend + 'static> {
pub state: AnvilState<BackendData>,
pub display_handle: DisplayHandle,
}
#[derive(Debug, Default)]
pub struct ClientState {
pub compositor_state: CompositorClientState,
@ -126,7 +121,7 @@ pub struct AnvilState<BackendData: Backend + 'static> {
pub socket_name: Option<String>,
pub display_handle: DisplayHandle,
pub running: Arc<AtomicBool>,
pub handle: LoopHandle<'static, CalloopData<BackendData>>,
pub handle: LoopHandle<'static, AnvilState<BackendData>>,
// desktop
pub space: Space<WindowElement>,
@ -525,7 +520,7 @@ smithay::delegate_xdg_foreign!(@<BackendData: Backend + 'static> AnvilState<Back
impl<BackendData: Backend + 'static> AnvilState<BackendData> {
pub fn init(
display: Display<AnvilState<BackendData>>,
handle: LoopHandle<'static, CalloopData<BackendData>>,
handle: LoopHandle<'static, AnvilState<BackendData>>,
backend_data: BackendData,
listen_on_socket: bool,
) -> AnvilState<BackendData> {
@ -559,7 +554,7 @@ impl<BackendData: Backend + 'static> AnvilState<BackendData> {
profiling::scope!("dispatch_clients");
// Safety: we don't drop the display
unsafe {
display.get_mut().dispatch_clients(&mut data.state).unwrap();
display.get_mut().dispatch_clients(data).unwrap();
}
Ok(PostAction::Continue)
},
@ -631,7 +626,7 @@ impl<BackendData: Backend + 'static> AnvilState<BackendData> {
client_fd: _,
display,
} => {
let mut wm = X11Wm::start_wm(data.state.handle.clone(), dh.clone(), connection, client)
let mut wm = X11Wm::start_wm(data.handle.clone(), dh.clone(), connection, client)
.expect("Failed to attach X11 Window Manager");
let cursor = Cursor::load();
let image = cursor.get_image(1, Duration::ZERO);
@ -641,11 +636,11 @@ impl<BackendData: Backend + 'static> AnvilState<BackendData> {
Point::from((image.xhot as u16, image.yhot as u16)),
)
.expect("Failed to set xwayland default cursor");
data.state.xwm = Some(wm);
data.state.xdisplay = Some(display);
data.xwm = Some(wm);
data.xdisplay = Some(display);
}
XWaylandEvent::Exited => {
let _ = data.state.xwm.take();
let _ = data.xwm.take();
}
});
if let Err(e) = ret {

52
anvil/src/udev.rs
View file

@ -13,7 +13,7 @@ use crate::{
drawing::*,
render::*,
shell::WindowElement,
state::{post_repaint, take_presentation_feedback, AnvilState, Backend, CalloopData},
state::{post_repaint, take_presentation_feedback, AnvilState, Backend},
};
#[cfg(feature = "renderer_sync")]
use smithay::backend::drm::compositor::PrimaryPlaneElement;
@ -288,26 +288,21 @@ pub fn run_udev() {
event_loop
.handle()
.insert_source(libinput_backend, move |mut event, _, data| {
let dh = data.state.backend_data.dh.clone();
let dh = data.backend_data.dh.clone();
if let InputEvent::DeviceAdded { device } = &mut event {
if device.has_capability(DeviceCapability::Keyboard) {
if let Some(led_state) = data
.state
.seat
.get_keyboard()
.map(|keyboard| keyboard.led_state())
{
if let Some(led_state) = data.seat.get_keyboard().map(|keyboard| keyboard.led_state()) {
device.led_update(led_state.into());
}
data.state.backend_data.keyboards.push(device.clone());
data.backend_data.keyboards.push(device.clone());
}
} else if let InputEvent::DeviceRemoved { ref device } = event {
if device.has_capability(DeviceCapability::Keyboard) {
data.state.backend_data.keyboards.retain(|item| item != device);
data.backend_data.keyboards.retain(|item| item != device);
}
}
data.state.process_input_event(&dh, event)
data.process_input_event(&dh, event)
})
.unwrap();
@ -319,7 +314,7 @@ pub fn run_udev() {
libinput_context.suspend();
info!("pausing session");
for backend in data.state.backend_data.backends.values_mut() {
for backend in data.backend_data.backends.values_mut() {
backend.drm.pause();
backend.active_leases.clear();
if let Some(lease_global) = backend.leasing_global.as_mut() {
@ -334,7 +329,6 @@ pub fn run_udev() {
error!("Failed to resume libinput context: {:?}", err);
}
for (node, backend) in data
.state
.backend_data
.backends
.iter_mut()
@ -358,7 +352,7 @@ pub fn run_udev() {
warn!("Failed to reset drm surface state: {}", err);
}
}
handle.insert_idle(move |data| data.state.render(node, None));
handle.insert_idle(move |data| data.render(node, None));
}
}
})
@ -447,19 +441,19 @@ pub fn run_udev() {
UdevEvent::Added { device_id, path } => {
if let Err(err) = DrmNode::from_dev_id(device_id)
.map_err(DeviceAddError::DrmNode)
.and_then(|node| data.state.device_added(node, &path))
.and_then(|node| data.device_added(node, &path))
{
error!("Skipping device {device_id}: {err}");
}
}
UdevEvent::Changed { device_id } => {
if let Ok(node) = DrmNode::from_dev_id(device_id) {
data.state.device_changed(node)
data.device_changed(node)
}
}
UdevEvent::Removed { device_id } => {
if let Ok(node) = DrmNode::from_dev_id(device_id) {
data.state.device_removed(node)
data.device_removed(node)
}
}
})
@ -484,16 +478,7 @@ pub fn run_udev() {
*/
while state.running.load(Ordering::SeqCst) {
let mut calloop_data = CalloopData {
state,
display_handle,
};
let result = event_loop.dispatch(Some(Duration::from_millis(16)), &mut calloop_data);
CalloopData {
state,
display_handle,
} = calloop_data;
let result = event_loop.dispatch(Some(Duration::from_millis(16)), &mut state);
if result.is_err() {
state.running.store(false, Ordering::SeqCst);
} else {
@ -862,10 +847,10 @@ impl AnvilState<UdevData> {
.handle
.insert_source(
notifier,
move |event, metadata, data: &mut CalloopData<_>| match event {
move |event, metadata, data: &mut AnvilState<_>| match event {
DrmEvent::VBlank(crtc) => {
profiling::scope!("vblank", &format!("{crtc:?}"));
data.state.frame_finish(node, crtc, metadata);
data.frame_finish(node, crtc, metadata);
}
DrmEvent::Error(error) => {
error!("{:?}", error);
@ -1350,7 +1335,7 @@ impl AnvilState<UdevData> {
self.handle
.insert_source(timer, move |_, _, data| {
data.state.render(dev_id, Some(crtc));
data.render(dev_id, Some(crtc));
TimeoutAction::Drop
})
.expect("failed to schedule frame timer");
@ -1504,7 +1489,7 @@ impl AnvilState<UdevData> {
let timer = Timer::from_duration(reschedule_duration);
self.handle
.insert_source(timer, move |_, _, data| {
data.state.render(node, Some(crtc));
data.render(node, Some(crtc));
TimeoutAction::Drop
})
.expect("failed to schedule frame timer");
@ -1520,7 +1505,7 @@ impl AnvilState<UdevData> {
&mut self,
node: DrmNode,
crtc: crtc::Handle,
evt_handle: LoopHandle<'static, CalloopData<UdevData>>,
evt_handle: LoopHandle<'static, AnvilState<UdevData>>,
) {
let device = if let Some(device) = self.backend_data.backends.get_mut(&node) {
device
@ -1547,8 +1532,7 @@ impl AnvilState<UdevData> {
// TODO dont reschedule after 3(?) retries
warn!("Failed to submit page_flip: {}", err);
let handle = evt_handle.clone();
evt_handle
.insert_idle(move |data| data.state.schedule_initial_render(node, crtc, handle));
evt_handle.insert_idle(move |data| data.schedule_initial_render(node, crtc, handle));
}
SwapBuffersError::ContextLost(err) => panic!("Rendering loop lost: {}", err),
}

17
anvil/src/winit.rs
View file

@ -48,7 +48,7 @@ use smithay::{
};
use tracing::{error, info, warn};
use crate::state::{post_repaint, take_presentation_feedback, AnvilState, Backend, CalloopData};
use crate::state::{post_repaint, take_presentation_feedback, AnvilState, Backend};
use crate::{drawing::*, render::*};
pub const OUTPUT_NAME: &str = "winit";
@ -234,9 +234,7 @@ pub fn run_winit() {
output.set_preferred(mode);
crate::shell::fixup_positions(&mut state.space, state.pointer.current_location());
}
WinitEvent::Input(event) => {
state.process_input_event_windowed(&display_handle, event, OUTPUT_NAME)
}
WinitEvent::Input(event) => state.process_input_event_windowed(event, OUTPUT_NAME),
_ => (),
});
@ -430,16 +428,7 @@ pub fn run_winit() {
}
}
let mut calloop_data = CalloopData {
state,
display_handle,
};
let result = event_loop.dispatch(Some(Duration::from_millis(1)), &mut calloop_data);
CalloopData {
state,
display_handle,
} = calloop_data;
let result = event_loop.dispatch(Some(Duration::from_millis(1)), &mut state);
if result.is_err() {
state.running.store(false, Ordering::SeqCst);
} else {

34
anvil/src/x11.rs
View file

@ -8,7 +8,7 @@ use std::{
use crate::{
drawing::*,
render::*,
state::{post_repaint, take_presentation_feedback, AnvilState, Backend, CalloopData},
state::{post_repaint, take_presentation_feedback, AnvilState, Backend},
};
#[cfg(feature = "egl")]
use smithay::backend::renderer::ImportEgl;
@ -260,32 +260,29 @@ pub fn run_x11() {
.handle()
.insert_source(backend, move |event, _, data| match event {
X11Event::CloseRequested { .. } => {
data.state.running.store(false, Ordering::SeqCst);
data.running.store(false, Ordering::SeqCst);
}
X11Event::Resized { new_size, .. } => {
let output = &output_clone;
let size = { (new_size.w as i32, new_size.h as i32).into() };
data.state.backend_data.mode = Mode {
data.backend_data.mode = Mode {
size,
refresh: 60_000,
};
output.delete_mode(output.current_mode().unwrap());
output.change_current_state(Some(data.state.backend_data.mode), None, None, None);
output.set_preferred(data.state.backend_data.mode);
crate::shell::fixup_positions(&mut data.state.space, data.state.pointer.current_location());
output.change_current_state(Some(data.backend_data.mode), None, None, None);
output.set_preferred(data.backend_data.mode);
crate::shell::fixup_positions(&mut data.space, data.pointer.current_location());
data.state.backend_data.render = true;
data.backend_data.render = true;
}
X11Event::PresentCompleted { .. } | X11Event::Refresh { .. } => {
data.state.backend_data.render = true;
}
X11Event::Input(event) => {
data.state
.process_input_event_windowed(&data.display_handle, event, OUTPUT_NAME)
data.backend_data.render = true;
}
X11Event::Input(event) => data.process_input_event_windowed(event, OUTPUT_NAME),
X11Event::Focus(false) => {
data.state.release_all_keys();
data.release_all_keys();
}
_ => {}
})
@ -461,16 +458,7 @@ pub fn run_x11() {
profiling::finish_frame!();
}
let mut calloop_data = CalloopData {
state,
display_handle,
};
let result = event_loop.dispatch(Some(Duration::from_millis(16)), &mut calloop_data);
CalloopData {
state,
display_handle,
} = calloop_data;
let result = event_loop.dispatch(Some(Duration::from_millis(16)), &mut state);
if result.is_err() {
state.running.store(false, Ordering::SeqCst);
} else {

41
wlcs_anvil/src/main_loop.rs
View file

@ -18,13 +18,13 @@ use smithay::{
channel::{Channel, Event as ChannelEvent},
EventLoop,
},
wayland_server::{protocol::wl_surface, Client, Display, DisplayHandle, Resource},
wayland_server::{protocol::wl_surface, Client, Display, Resource},
},
utils::{IsAlive, Scale, SERIAL_COUNTER as SCOUNTER},
wayland::compositor,
};
use anvil::{drawing::PointerElement, render::*, state::Backend, AnvilState, CalloopData, ClientState};
use anvil::{drawing::PointerElement, render::*, state::Backend, AnvilState, ClientState};
use crate::WlcsEvent;
@ -41,27 +41,24 @@ impl Backend for TestState {
fn reset_buffers(&mut self, _output: &Output) {}
fn early_import(&mut self, _surface: &wl_surface::WlSurface) {}
fn update_led_state(&mut self, led_state: smithay::input::keyboard::LedState) {}
fn update_led_state(&mut self, _led_state: smithay::input::keyboard::LedState) {}
}
pub fn run(channel: Channel<WlcsEvent>) {
let mut event_loop =
EventLoop::<CalloopData<TestState>>::try_new().expect("Failed to init the event loop.");
EventLoop::<AnvilState<TestState>>::try_new().expect("Failed to init the event loop.");
let display = Display::new().expect("Failed to init display");
let mut display_handle = display.handle();
let test_state = TestState {
clients: HashMap::new(),
};
let mut state = AnvilState::init(display, event_loop.handle(), test_state, false);
event_loop
.handle()
.insert_source(channel, move |event, &mut (), data| match event {
ChannelEvent::Msg(evt) => handle_event(evt, &mut data.state, &mut data.display_handle),
ChannelEvent::Closed => handle_event(WlcsEvent::Exit, &mut data.state, &mut data.display_handle),
ChannelEvent::Msg(evt) => handle_event(evt, data),
ChannelEvent::Closed => handle_event(WlcsEvent::Exit, data),
})
.unwrap();
@ -81,7 +78,7 @@ pub fn run(channel: Channel<WlcsEvent>) {
model: "WLCS".into(),
},
);
let _global = output.create_global::<AnvilState<TestState>>(&display_handle);
let _global = output.create_global::<AnvilState<TestState>>(&state.display_handle);
output.change_current_state(Some(mode), None, None, Some((0, 0).into()));
output.set_preferred(mode);
state.space.map_output(&output, (0, 0));
@ -156,31 +153,25 @@ pub fn run(channel: Channel<WlcsEvent>) {
})
});
let mut calloop_data = CalloopData {
state,
display_handle,
};
let result = event_loop.dispatch(Some(Duration::from_millis(16)), &mut calloop_data);
CalloopData {
state,
display_handle,
} = calloop_data;
if result.is_err() {
if event_loop
.dispatch(Some(Duration::from_millis(16)), &mut state)
.is_err()
{
state.running.store(false, Ordering::SeqCst);
} else {
state.space.refresh();
state.popups.cleanup();
display_handle.flush_clients().unwrap();
state.display_handle.flush_clients().unwrap();
}
}
}
fn handle_event(event: WlcsEvent, state: &mut AnvilState<TestState>, display_handle: &mut DisplayHandle) {
fn handle_event(event: WlcsEvent, state: &mut AnvilState<TestState>) {
match event {
WlcsEvent::Exit => state.running.store(false, Ordering::SeqCst),
WlcsEvent::NewClient { stream, client_id } => {
let client = display_handle
let client = state
.display_handle
.insert_client(stream, Arc::new(ClientState::default()))
.expect("Failed to insert client");
state.backend_data.clients.insert(client_id, client);
@ -194,7 +185,7 @@ fn handle_event(event: WlcsEvent, state: &mut AnvilState<TestState>, display_han
let client = state.backend_data.clients.get(&client_id);
let toplevel = state.space.elements().find(|w| {
if let Some(surface) = w.wl_surface() {
display_handle.get_client(surface.id()).ok().as_ref() == client
state.display_handle.get_client(surface.id()).ok().as_ref() == client
&& surface.id().protocol_id() == surface_id
} else {
false