Miroirs/pinnacle
1
0
Fork 0
mirror of https://github.com/pinnacle-comp/pinnacle.git synced 2025-02-06 20:46:37 +01:00
Code Issues Projects Releases Packages Wiki Activity

Remove CalloopData

Browse source 
This was a remnant of Anvil
This commit is contained in:
Ottatop 2024-02-16 22:37:53 -06:00
parent fa2eed1adc
commit 8a2a6a3185
6 changed files with 137 additions and 180 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
src/backend/udev.rs
View file

@ -76,7 +76,7 @@ use crate::{
config::ConnectorSavedState, config::ConnectorSavedState,
output::OutputName, output::OutputName,
render::{pointer::PointerElement, take_presentation_feedback}, render::{pointer::PointerElement, take_presentation_feedback},
state::{CalloopData, State, SurfaceDmabufFeedback, WithState}, state::{State, SurfaceDmabufFeedback, WithState},
window::WindowElement, window::WindowElement,
}; };
@ -131,7 +131,7 @@ impl Backend {
impl Udev { impl Udev {
/// Schedule a new render that will cause the compositor to redraw everything. /// Schedule a new render that will cause the compositor to redraw everything.
pub fn schedule_render(&mut self, loop_handle: &LoopHandle<CalloopData>, output: &Output) { pub fn schedule_render(&mut self, loop_handle: &LoopHandle<State>, output: &Output) {
// tracing::debug!("schedule_render on output {}", output.name()); // tracing::debug!("schedule_render on output {}", output.name());
let Some(surface) = render_surface_for_output(output, &mut self.backends) else { let Some(surface) = render_surface_for_output(output, &mut self.backends) else {
@ -141,8 +141,8 @@ impl Udev {
match &surface.render_state { match &surface.render_state {
RenderState::Idle => { RenderState::Idle => {
let output = output.clone(); let output = output.clone();
let token = loop_handle.insert_idle(move |data| { let token = loop_handle.insert_idle(move |state| {
data.state.render_surface(&output); state.render_surface(&output);
}); });
surface.render_state = RenderState::Scheduled(token); surface.render_state = RenderState::Scheduled(token);
@ -189,8 +189,8 @@ impl State {
// Wait for the clear to commit before switching // Wait for the clear to commit before switching
self.schedule( self.schedule(
|data| { |state| {
let udev = data.state.backend.udev(); let udev = state.backend.udev();
!udev !udev
.backends .backends
.values() .values()
@ -198,8 +198,8 @@ impl State {
.map(|surface| surface.compositor.surface()) .map(|surface| surface.compositor.surface())
.any(|drm_surf| drm_surf.commit_pending()) .any(|drm_surf| drm_surf.commit_pending())
}, },
move |data| { move |state| {
let udev = data.state.backend.udev_mut(); let udev = state.backend.udev_mut();
if let Err(err) = udev.session.change_vt(vt) { if let Err(err) = udev.session.change_vt(vt) {
tracing::error!("Failed to switch to vt {vt}: {err}"); tracing::error!("Failed to switch to vt {vt}: {err}");
} }
@ -301,25 +301,25 @@ pub fn run_udev() -> anyhow::Result<()> {
event_loop event_loop
.handle() .handle()
.insert_source(udev_backend, move |event, _, data| match event { .insert_source(udev_backend, move |event, _, state| match event {
// GPU connected // GPU connected
UdevEvent::Added { device_id, path } => { UdevEvent::Added { device_id, path } => {
if let Err(err) = DrmNode::from_dev_id(device_id) if let Err(err) = DrmNode::from_dev_id(device_id)
.map_err(DeviceAddError::DrmNode) .map_err(DeviceAddError::DrmNode)
.and_then(|node| data.state.device_added(node, &path)) .and_then(|node| state.device_added(node, &path))
{ {
tracing::error!("Skipping device {device_id}: {err}"); tracing::error!("Skipping device {device_id}: {err}");
} }
} }
UdevEvent::Changed { device_id } => { UdevEvent::Changed { device_id } => {
if let Ok(node) = DrmNode::from_dev_id(device_id) { if let Ok(node) = DrmNode::from_dev_id(device_id) {
data.state.device_changed(node) state.device_changed(node)
} }
} }
// GPU disconnected // GPU disconnected
UdevEvent::Removed { device_id } => { UdevEvent::Removed { device_id } => {
if let Ok(node) = DrmNode::from_dev_id(device_id) { if let Ok(node) = DrmNode::from_dev_id(device_id) {
data.state.device_removed(node) state.device_removed(node)
} }
} }
}) })
@ -338,9 +338,9 @@ pub fn run_udev() -> anyhow::Result<()> {
let insert_ret = event_loop let insert_ret = event_loop
.handle() .handle()
.insert_source(libinput_backend, move |event, _, data| { .insert_source(libinput_backend, move |event, _, state| {
data.state.apply_libinput_settings(&event); state.apply_libinput_settings(&event);
data.state.process_input_event(event); state.process_input_event(event);
}); });
if let Err(err) = insert_ret { if let Err(err) = insert_ret {
@ -349,8 +349,8 @@ pub fn run_udev() -> anyhow::Result<()> {
event_loop event_loop
.handle() .handle()
.insert_source(notifier, move |event, _, data| { .insert_source(notifier, move |event, _, state| {
let udev = data.state.backend.udev_mut(); let udev = state.backend.udev_mut();
match event { match event {
session::Event::PauseSession => { session::Event::PauseSession => {
@ -398,13 +398,12 @@ pub fn run_udev() -> anyhow::Result<()> {
for (node, connectors) in connectors { for (node, connectors) in connectors {
for (connector, crtc) in connectors { for (connector, crtc) in connectors {
data.state state.connector_disconnected(node, connector.clone(), crtc);
.connector_disconnected(node, connector.clone(), crtc); state.connector_connected(node, connector, crtc);
data.state.connector_connected(node, connector, crtc);
} }
} }
for output in data.state.space.outputs().cloned().collect::<Vec<_>>() { for output in state.space.outputs().cloned().collect::<Vec<_>>() {
data.state.schedule_render(&output); state.schedule_render(&output);
} }
} }
} }
@ -515,18 +514,16 @@ pub fn run_udev() -> anyhow::Result<()> {
event_loop.run( event_loop.run(
Some(Duration::from_micros(((1.0 / 144.0) * 1000000.0) as u64)), Some(Duration::from_micros(((1.0 / 144.0) * 1000000.0) as u64)),
&mut CalloopData { &mut state,
state, |state| {
display_handle, state.space.refresh();
}, state.popup_manager.cleanup();
|data| { state
data.state.space.refresh(); .display_handle
data.state.popup_manager.cleanup();
data.display_handle
.flush_clients() .flush_clients()
.expect("failed to flush_clients"); .expect("failed to flush_clients");
data.state.focus_state.fix_up_focus(&mut data.state.space); state.focus_state.fix_up_focus(&mut state.space);
}, },
)?; )?;
@ -743,7 +740,7 @@ impl State {
let registration_token = self let registration_token = self
.loop_handle .loop_handle
.insert_source(notifier, move |event, metadata, data| match event { .insert_source(notifier, move |event, metadata, state| match event {
DrmEvent::VBlank(crtc) => { DrmEvent::VBlank(crtc) => {
// { TODO: // { TODO:
// let udev = data.state.backend.udev_mut(); // let udev = data.state.backend.udev_mut();
@ -753,7 +750,7 @@ impl State {
// // tracing::debug!(time = diff.as_secs_f64(), "Time since last vblank"); // // tracing::debug!(time = diff.as_secs_f64(), "Time since last vblank");
// udev.last_vblank_time = now; // udev.last_vblank_time = now;
// } // }
data.state.on_vblank(node, crtc, metadata); state.on_vblank(node, crtc, metadata);
} }
DrmEvent::Error(error) => { DrmEvent::Error(error) => {
tracing::error!("{:?}", error); tracing::error!("{:?}", error);

22
src/backend/winit.rs
View file

@ -30,7 +30,7 @@ use smithay::{
use crate::{ use crate::{
render::{pointer::PointerElement, take_presentation_feedback}, render::{pointer::PointerElement, take_presentation_feedback},
state::{CalloopData, State}, state::State,
}; };
use super::{Backend, BackendData}; use super::{Backend, BackendData};
@ -63,7 +63,7 @@ impl Backend {
/// Start Pinnacle as a window in a graphical environment. /// Start Pinnacle as a window in a graphical environment.
pub fn run_winit() -> anyhow::Result<()> { pub fn run_winit() -> anyhow::Result<()> {
let mut event_loop: EventLoop<CalloopData> = EventLoop::try_new()?; let mut event_loop: EventLoop<State> = EventLoop::try_new()?;
let display: Display<State> = Display::new()?; let display: Display<State> = Display::new()?;
let display_handle = display.handle(); let display_handle = display.handle();
@ -190,9 +190,7 @@ pub fn run_winit() -> anyhow::Result<()> {
let insert_ret = let insert_ret =
state state
.loop_handle .loop_handle
.insert_source(Timer::immediate(), move |_instant, _metadata, data| { .insert_source(Timer::immediate(), move |_instant, _metadata, state| {
let state = &mut data.state;
let status = winit_evt_loop.dispatch_new_events(|event| match event { let status = winit_evt_loop.dispatch_new_events(|event| match event {
WinitEvent::Resized { WinitEvent::Resized {
size, size,
@ -237,14 +235,12 @@ pub fn run_winit() -> anyhow::Result<()> {
event_loop.run( event_loop.run(
Some(Duration::from_micros(((1.0 / 144.0) * 1000000.0) as u64)), Some(Duration::from_micros(((1.0 / 144.0) * 1000000.0) as u64)),
&mut CalloopData { &mut state,
display_handle, |state| {
state, state.space.refresh();
}, state.popup_manager.cleanup();
|data| { state
data.state.space.refresh(); .display_handle
data.state.popup_manager.cleanup();
data.display_handle
.flush_clients() .flush_clients()
.expect("failed to flush client buffers"); .expect("failed to flush client buffers");
}, },

17
src/config.rs
View file

@ -4,7 +4,6 @@ use crate::{
}, },
input::ModifierMask, input::ModifierMask,
output::OutputName, output::OutputName,
state::CalloopData,
tag::Tag, tag::Tag,
window::rules::{WindowRule, WindowRuleCondition}, window::rules::{WindowRule, WindowRuleCondition},
}; };
@ -173,7 +172,7 @@ pub struct Config {
} }
impl Config { impl Config {
pub fn clear(&mut self, loop_handle: &LoopHandle<CalloopData>) { pub fn clear(&mut self, loop_handle: &LoopHandle<State>) {
self.window_rules.clear(); self.window_rules.clear();
self.output_callback_senders.clear(); self.output_callback_senders.clear();
self.connector_saved_states.clear(); self.connector_saved_states.clear();
@ -358,9 +357,9 @@ impl State {
let token = self let token = self
.loop_handle .loop_handle
.insert_source(ping_source, move |_, _, data| { .insert_source(ping_source, move |_, _, state| {
tracing::error!("Config crashed! Falling back to default Lua config"); tracing::error!("Config crashed! Falling back to default Lua config");
data.state state
.start_config(&default_lua_config_dir) .start_config(&default_lua_config_dir)
.expect("failed to start default lua config"); .expect("failed to start default lua config");
})?; })?;
@ -435,8 +434,8 @@ impl State {
calloop::channel::channel::<Box<dyn FnOnce(&mut Self) + Send>>(); calloop::channel::channel::<Box<dyn FnOnce(&mut Self) + Send>>();
self.loop_handle self.loop_handle
.insert_source(grpc_receiver, |msg, _, data| match msg { .insert_source(grpc_receiver, |msg, _, state| match msg {
Event::Msg(f) => f(&mut data.state), Event::Msg(f) => f(state),
Event::Closed => tracing::error!("grpc receiver was closed"), Event::Closed => tracing::error!("grpc receiver was closed"),
}) })
.expect("failed to insert grpc_receiver into loop"); .expect("failed to insert grpc_receiver into loop");
@ -490,9 +489,9 @@ impl State {
// | fast at startup then I think there's a chance that the gRPC server // | fast at startup then I think there's a chance that the gRPC server
// | could get started twice. // | could get started twice.
None => self.schedule( None => self.schedule(
|data| data.state.xdisplay.is_some(), |state| state.xdisplay.is_some(),
move |data| { move |state| {
data.state.grpc_server_join_handle = Some(tokio::spawn(async move { state.grpc_server_join_handle = Some(tokio::spawn(async move {
if let Err(err) = grpc_server.serve_with_incoming(uds_stream).await { if let Err(err) = grpc_server.serve_with_incoming(uds_stream).await {
tracing::error!("gRPC server error: {err}"); tracing::error!("gRPC server error: {err}");
} }

26
src/handlers.rs
View file

@ -59,7 +59,7 @@ use smithay::{
use crate::{ use crate::{
focus::FocusTarget, focus::FocusTarget,
state::{CalloopData, ClientState, State, WithState}, state::{ClientState, State, WithState},
window::WindowElement, window::WindowElement,
}; };
@ -90,10 +90,10 @@ impl CompositorHandler for State {
let client = surface let client = surface
.client() .client()
.expect("Surface has no client/is no longer alive"); .expect("Surface has no client/is no longer alive");
let res = state.loop_handle.insert_source(source, move |_, _, data| { let res = state.loop_handle.insert_source(source, move |_, _, state| {
data.state state
.client_compositor_state(&client) .client_compositor_state(&client)
.blocker_cleared(&mut data.state, &data.display_handle); .blocker_cleared(state, &state.display_handle.clone());
Ok(()) Ok(())
}); });
if res.is_ok() { if res.is_ok() {
@ -107,9 +107,9 @@ impl CompositorHandler for State {
fn commit(&mut self, surface: &WlSurface) { fn commit(&mut self, surface: &WlSurface) {
tracing::trace!("commit on surface {surface:?}"); tracing::trace!("commit on surface {surface:?}");
X11Wm::commit_hook::<CalloopData>(surface); X11Wm::commit_hook::<State>(surface);
utils::on_commit_buffer_handler::<Self>(surface); utils::on_commit_buffer_handler::<State>(surface);
self.backend.early_import(surface); self.backend.early_import(surface);
let mut root = surface.clone(); let mut root = surface.clone();
@ -167,13 +167,13 @@ impl CompositorHandler for State {
); );
} }
self.loop_handle.insert_idle(move |data| { self.loop_handle.insert_idle(move |state| {
data.state state
.seat .seat
.get_keyboard() .get_keyboard()
.expect("Seat had no keyboard") // FIXME: actually handle error .expect("Seat had no keyboard") // FIXME: actually handle error
.set_focus( .set_focus(
&mut data.state, state,
Some(FocusTarget::Window(new_window)), Some(FocusTarget::Window(new_window)),
SERIAL_COUNTER.next_serial(), SERIAL_COUNTER.next_serial(),
); );
@ -527,8 +527,8 @@ impl WlrLayerShellHandler for State {
.expect("failed to map layer surface"); .expect("failed to map layer surface");
drop(map); // wow i really love refcells haha drop(map); // wow i really love refcells haha
self.loop_handle.insert_idle(move |data| { self.loop_handle.insert_idle(move |state| {
data.state.update_windows(&output); state.update_windows(&output);
}); });
} }
@ -547,8 +547,8 @@ impl WlrLayerShellHandler for State {
} }
if let Some(output) = output { if let Some(output) = output {
self.loop_handle.insert_idle(move |data| { self.loop_handle.insert_idle(move |state| {
data.state.update_windows(&output); state.update_windows(&output);
}); });
} }
} }

134
src/handlers/xwayland.rs
View file

@ -23,13 +23,13 @@ use smithay::{
use crate::{ use crate::{
focus::FocusTarget, focus::FocusTarget,
state::{CalloopData, WithState}, state::{State, WithState},
window::{window_state::FloatingOrTiled, WindowElement}, window::{window_state::FloatingOrTiled, WindowElement},
}; };
impl XwmHandler for CalloopData { impl XwmHandler for State {
fn xwm_state(&mut self, _xwm: XwmId) -> &mut X11Wm { fn xwm_state(&mut self, _xwm: XwmId) -> &mut X11Wm {
self.state.xwm.as_mut().expect("xwm not in state") self.xwm.as_mut().expect("xwm not in state")
} }
fn new_window(&mut self, _xwm: XwmId, _window: X11Surface) {} fn new_window(&mut self, _xwm: XwmId, _window: X11Surface) {}
@ -42,24 +42,21 @@ impl XwmHandler for CalloopData {
assert!(!window.is_override_redirect()); assert!(!window.is_override_redirect());
let window = WindowElement::X11(window); let window = WindowElement::X11(window);
self.state.space.map_element(window.clone(), (0, 0), true); self.space.map_element(window.clone(), (0, 0), true);
let bbox = self let bbox = self
.state
.space .space
.element_bbox(&window) .element_bbox(&window)
.expect("called element_bbox on an unmapped window"); .expect("called element_bbox on an unmapped window");
let output_size = self let output_size = self
.state
.focus_state .focus_state
.focused_output .focused_output
.as_ref() .as_ref()
.and_then(|op| self.state.space.output_geometry(op)) .and_then(|op| self.space.output_geometry(op))
.map(|geo| geo.size) .map(|geo| geo.size)
.unwrap_or((2, 2).into()); .unwrap_or((2, 2).into());
let output_loc = self let output_loc = self
.state
.focus_state .focus_state
.focused_output .focused_output
.as_ref() .as_ref()
@ -79,7 +76,7 @@ impl XwmHandler for CalloopData {
unreachable!() unreachable!()
}; };
self.state.space.map_element(window.clone(), loc, true); self.space.map_element(window.clone(), loc, true);
surface.set_mapped(true).expect("failed to map x11 window"); surface.set_mapped(true).expect("failed to map x11 window");
let bbox = Rectangle::from_loc_and_size(loc, bbox.size); let bbox = Rectangle::from_loc_and_size(loc, bbox.size);
@ -91,8 +88,8 @@ impl XwmHandler for CalloopData {
// TODO: ssd // TODO: ssd
if let (Some(output), _) | (None, Some(output)) = ( if let (Some(output), _) | (None, Some(output)) = (
&self.state.focus_state.focused_output, &self.focus_state.focused_output,
self.state.space.outputs().next(), self.space.outputs().next(),
) { ) {
window.place_on_output(output); window.place_on_output(output);
} }
@ -103,23 +100,23 @@ impl XwmHandler for CalloopData {
}); });
} }
self.state.windows.push(window.clone()); self.windows.push(window.clone());
self.state.focus_state.set_focus(window.clone()); self.focus_state.set_focus(window.clone());
self.state.apply_window_rules(&window); self.apply_window_rules(&window);
if let Some(output) = window.output(&self.state) { if let Some(output) = window.output(self) {
self.state.update_windows(&output); self.update_windows(&output);
} }
self.state.loop_handle.insert_idle(move |data| { self.loop_handle.insert_idle(move |state| {
data.state state
.seat .seat
.get_keyboard() .get_keyboard()
.expect("Seat had no keyboard") // FIXME: actually handle error .expect("Seat had no keyboard") // FIXME: actually handle error
.set_focus( .set_focus(
&mut data.state, state,
Some(FocusTarget::Window(window)), Some(FocusTarget::Window(window)),
SERIAL_COUNTER.next_serial(), SERIAL_COUNTER.next_serial(),
); );
@ -134,54 +131,52 @@ impl XwmHandler for CalloopData {
let loc = window.geometry().loc; let loc = window.geometry().loc;
let window = WindowElement::X11OverrideRedirect(window); let window = WindowElement::X11OverrideRedirect(window);
self.state.windows.push(window.clone()); self.windows.push(window.clone());
if let (Some(output), _) | (None, Some(output)) = ( if let (Some(output), _) | (None, Some(output)) = (
&self.state.focus_state.focused_output, &self.focus_state.focused_output,
self.state.space.outputs().next(), self.space.outputs().next(),
) { ) {
window.place_on_output(output); window.place_on_output(output);
} }
self.state.space.map_element(window.clone(), loc, true); self.space.map_element(window.clone(), loc, true);
self.state.focus_state.set_focus(window); self.focus_state.set_focus(window);
} }
fn unmapped_window(&mut self, _xwm: XwmId, window: X11Surface) { fn unmapped_window(&mut self, _xwm: XwmId, window: X11Surface) {
self.state.focus_state.focus_stack.retain(|win| { self.focus_state.focus_stack.retain(|win| {
win.wl_surface() win.wl_surface()
.is_some_and(|surf| Some(surf) != window.wl_surface()) .is_some_and(|surf| Some(surf) != window.wl_surface())
}); });
let win = self let win = self
.state
.space .space
.elements() .elements()
.find(|elem| matches!(elem, WindowElement::X11(surface) if surface == &window)) .find(|elem| matches!(elem, WindowElement::X11(surface) if surface == &window))
.cloned(); .cloned();
if let Some(win) = win { if let Some(win) = win {
self.state.space.unmap_elem(&win); self.space.unmap_elem(&win);
if let Some(output) = win.output(&self.state) { if let Some(output) = win.output(self) {
self.state.update_windows(&output); self.update_windows(&output);
let focus = self.state.focused_window(&output).map(FocusTarget::Window); let focus = self.focused_window(&output).map(FocusTarget::Window);
if let Some(FocusTarget::Window(win)) = &focus { if let Some(FocusTarget::Window(win)) = &focus {
self.state.space.raise_element(win, true); self.space.raise_element(win, true);
if let WindowElement::Wayland(win) = &win { if let WindowElement::Wayland(win) = &win {
win.toplevel().send_configure(); win.toplevel().send_configure();
} }
} }
self.state self.seat
.seat
.get_keyboard() .get_keyboard()
.expect("Seat had no keyboard") .expect("Seat had no keyboard")
.set_focus(&mut self.state, focus, SERIAL_COUNTER.next_serial()); .set_focus(self, focus, SERIAL_COUNTER.next_serial());
self.state.schedule_render(&output); self.schedule_render(&output);
} }
} }
@ -192,13 +187,12 @@ impl XwmHandler for CalloopData {
} }
fn destroyed_window(&mut self, _xwm: XwmId, window: X11Surface) { fn destroyed_window(&mut self, _xwm: XwmId, window: X11Surface) {
self.state.focus_state.focus_stack.retain(|win| { self.focus_state.focus_stack.retain(|win| {
win.wl_surface() win.wl_surface()
.is_some_and(|surf| Some(surf) != window.wl_surface()) .is_some_and(|surf| Some(surf) != window.wl_surface())
}); });
let win = self let win = self
.state
.windows .windows
.iter() .iter()
.find(|elem| { .find(|elem| {
@ -215,30 +209,28 @@ impl XwmHandler for CalloopData {
tracing::debug!("removing x11 window from windows"); tracing::debug!("removing x11 window from windows");
// INFO: comparing the windows doesn't work so wlsurface it is // INFO: comparing the windows doesn't work so wlsurface it is
// self.state.windows.retain(|elem| &win != elem); // self.windows.retain(|elem| &win != elem);
self.state self.windows
.windows
.retain(|elem| win.wl_surface() != elem.wl_surface()); .retain(|elem| win.wl_surface() != elem.wl_surface());
if let Some(output) = win.output(&self.state) { if let Some(output) = win.output(self) {
self.state.update_windows(&output); self.update_windows(&output);
let focus = self.state.focused_window(&output).map(FocusTarget::Window); let focus = self.focused_window(&output).map(FocusTarget::Window);
if let Some(FocusTarget::Window(win)) = &focus { if let Some(FocusTarget::Window(win)) = &focus {
self.state.space.raise_element(win, true); self.space.raise_element(win, true);
if let WindowElement::Wayland(win) = &win { if let WindowElement::Wayland(win) = &win {
win.toplevel().send_configure(); win.toplevel().send_configure();
} }
} }
self.state self.seat
.seat
.get_keyboard() .get_keyboard()
.expect("Seat had no keyboard") .expect("Seat had no keyboard")
.set_focus(&mut self.state, focus, SERIAL_COUNTER.next_serial()); .set_focus(self, focus, SERIAL_COUNTER.next_serial());
self.state.schedule_render(&output); self.schedule_render(&output);
} }
} }
tracing::debug!("destroyed x11 window"); tracing::debug!("destroyed x11 window");
@ -275,7 +267,6 @@ impl XwmHandler for CalloopData {
_above: Option<smithay::reexports::x11rb::protocol::xproto::Window>, _above: Option<smithay::reexports::x11rb::protocol::xproto::Window>,
) { ) {
let Some(win) = self let Some(win) = self
.state
.space .space
.elements() .elements()
.find(|elem| matches!(elem, WindowElement::X11(surface) if surface == &window)) .find(|elem| matches!(elem, WindowElement::X11(surface) if surface == &window))
@ -284,7 +275,7 @@ impl XwmHandler for CalloopData {
return; return;
}; };
self.state.space.map_element(win, geometry.loc, true); self.space.map_element(win, geometry.loc, true);
} }
fn maximize_request(&mut self, _xwm: XwmId, window: X11Surface) { fn maximize_request(&mut self, _xwm: XwmId, window: X11Surface) {
@ -294,7 +285,7 @@ impl XwmHandler for CalloopData {
let Some(window) = window let Some(window) = window
.wl_surface() .wl_surface()
.and_then(|surf| self.state.window_for_surface(&surf)) .and_then(|surf| self.window_for_surface(&surf))
else { else {
return; return;
}; };
@ -311,7 +302,7 @@ impl XwmHandler for CalloopData {
let Some(window) = window let Some(window) = window
.wl_surface() .wl_surface()
.and_then(|surf| self.state.window_for_surface(&surf)) .and_then(|surf| self.window_for_surface(&surf))
else { else {
return; return;
}; };
@ -328,7 +319,7 @@ impl XwmHandler for CalloopData {
let Some(window) = window let Some(window) = window
.wl_surface() .wl_surface()
.and_then(|surf| self.state.window_for_surface(&surf)) .and_then(|surf| self.window_for_surface(&surf))
else { else {
return; return;
}; };
@ -345,7 +336,7 @@ impl XwmHandler for CalloopData {
let Some(window) = window let Some(window) = window
.wl_surface() .wl_surface()
.and_then(|surf| self.state.window_for_surface(&surf)) .and_then(|surf| self.window_for_surface(&surf))
else { else {
return; return;
}; };
@ -363,12 +354,12 @@ impl XwmHandler for CalloopData {
resize_edge: smithay::xwayland::xwm::ResizeEdge, resize_edge: smithay::xwayland::xwm::ResizeEdge,
) { ) {
let Some(wl_surf) = window.wl_surface() else { return }; let Some(wl_surf) = window.wl_surface() else { return };
let seat = self.state.seat.clone(); let seat = self.seat.clone();
// We use the server one and not the client because windows like Steam don't provide // We use the server one and not the client because windows like Steam don't provide
// GrabStartData, so we need to create it ourselves. // GrabStartData, so we need to create it ourselves.
crate::grab::resize_grab::resize_request_server( crate::grab::resize_grab::resize_request_server(
&mut self.state, self,
&wl_surf, &wl_surf,
&seat, &seat,
SERIAL_COUNTER.next_serial(), SERIAL_COUNTER.next_serial(),
@ -379,12 +370,12 @@ impl XwmHandler for CalloopData {
fn move_request(&mut self, _xwm: XwmId, window: X11Surface, button: u32) { fn move_request(&mut self, _xwm: XwmId, window: X11Surface, button: u32) {
let Some(wl_surf) = window.wl_surface() else { return }; let Some(wl_surf) = window.wl_surface() else { return };
let seat = self.state.seat.clone(); let seat = self.seat.clone();
// We use the server one and not the client because windows like Steam don't provide // We use the server one and not the client because windows like Steam don't provide
// GrabStartData, so we need to create it ourselves. // GrabStartData, so we need to create it ourselves.
crate::grab::move_grab::move_request_server( crate::grab::move_grab::move_request_server(
&mut self.state, self,
&wl_surf, &wl_surf,
&seat, &seat,
SERIAL_COUNTER.next_serial(), SERIAL_COUNTER.next_serial(),
@ -393,8 +384,7 @@ impl XwmHandler for CalloopData {
} }
fn allow_selection_access(&mut self, xwm: XwmId, _selection: SelectionTarget) -> bool { fn allow_selection_access(&mut self, xwm: XwmId, _selection: SelectionTarget) -> bool {
self.state self.seat
.seat
.get_keyboard() .get_keyboard()
.and_then(|kb| kb.current_focus()) .and_then(|kb| kb.current_focus())
.is_some_and(|focus| { .is_some_and(|focus| {
@ -415,9 +405,7 @@ impl XwmHandler for CalloopData {
) { ) {
match selection { match selection {
SelectionTarget::Clipboard => { SelectionTarget::Clipboard => {
if let Err(err) = if let Err(err) = request_data_device_client_selection(&self.seat, mime_type, fd) {
request_data_device_client_selection(&self.state.seat, mime_type, fd)
{
tracing::error!( tracing::error!(
?err, ?err,
"Failed to request current wayland clipboard for XWayland" "Failed to request current wayland clipboard for XWayland"
@ -425,8 +413,7 @@ impl XwmHandler for CalloopData {
} }
} }
SelectionTarget::Primary => { 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) {
{
tracing::error!( tracing::error!(
?err, ?err,
"Failed to request current wayland primary selection for XWayland" "Failed to request current wayland primary selection for XWayland"
@ -439,15 +426,10 @@ impl XwmHandler for CalloopData {
fn new_selection(&mut self, _xwm: XwmId, selection: SelectionTarget, mime_types: Vec<String>) { fn new_selection(&mut self, _xwm: XwmId, selection: SelectionTarget, mime_types: Vec<String>) {
match selection { match selection {
SelectionTarget::Clipboard => { SelectionTarget::Clipboard => {
set_data_device_selection( set_data_device_selection(&self.display_handle, &self.seat, mime_types, ());
&self.state.display_handle,
&self.state.seat,
mime_types,
(),
);
} }
SelectionTarget::Primary => { SelectionTarget::Primary => {
set_primary_selection(&self.state.display_handle, &self.state.seat, mime_types, ()); set_primary_selection(&self.display_handle, &self.seat, mime_types, ());
} }
} }
} }
@ -455,13 +437,13 @@ impl XwmHandler for CalloopData {
fn cleared_selection(&mut self, _xwm: XwmId, selection: SelectionTarget) { fn cleared_selection(&mut self, _xwm: XwmId, selection: SelectionTarget) {
match selection { match selection {
SelectionTarget::Clipboard => { SelectionTarget::Clipboard => {
if current_data_device_selection_userdata(&self.state.seat).is_some() { if current_data_device_selection_userdata(&self.seat).is_some() {
clear_data_device_selection(&self.state.display_handle, &self.state.seat); clear_data_device_selection(&self.display_handle, &self.seat);
} }
} }
SelectionTarget::Primary => { SelectionTarget::Primary => {
if current_primary_selection_userdata(&self.state.seat).is_some() { if current_primary_selection_userdata(&self.seat).is_some() {
clear_primary_selection(&self.state.display_handle, &self.state.seat); clear_primary_selection(&self.display_handle, &self.seat);
} }
} }
} }

53
src/state.rs
View file

@ -43,7 +43,7 @@ pub struct State {
/// A loop signal used to stop the compositor /// A loop signal used to stop the compositor
pub loop_signal: LoopSignal, pub loop_signal: LoopSignal,
/// A handle to the event loop /// A handle to the event loop
pub loop_handle: LoopHandle<'static, CalloopData>, pub loop_handle: LoopHandle<'static, Self>,
pub display_handle: DisplayHandle, pub display_handle: DisplayHandle,
pub clock: Clock<Monotonic>, pub clock: Clock<Monotonic>,
@ -99,7 +99,7 @@ impl State {
backend: Backend, backend: Backend,
display: Display<Self>, display: Display<Self>,
loop_signal: LoopSignal, loop_signal: LoopSignal,
loop_handle: LoopHandle<'static, CalloopData>, loop_handle: LoopHandle<'static, Self>,
) -> anyhow::Result<Self> { ) -> anyhow::Result<Self> {
let socket = ListeningSocketSource::new_auto()?; let socket = ListeningSocketSource::new_auto()?;
let socket_name = socket.socket_name().to_os_string(); let socket_name = socket.socket_name().to_os_string();
@ -137,20 +137,20 @@ impl State {
loop_handle.insert_source( loop_handle.insert_source(
Generic::new(display, Interest::READ, Mode::Level), Generic::new(display, Interest::READ, Mode::Level),
|_readiness, display, data| { |_readiness, display, state| {
// Safety: we don't drop the display // Safety: we don't drop the display
unsafe { unsafe {
display display
.get_mut() .get_mut()
.dispatch_clients(&mut data.state) .dispatch_clients(state)
.expect("failed to dispatch clients"); .expect("failed to dispatch clients");
} }
Ok(PostAction::Continue) Ok(PostAction::Continue)
}, },
)?; )?;
loop_handle.insert_idle(|data| { loop_handle.insert_idle(|state| {
if let Err(err) = data.state.start_config(crate::config::get_config_dir()) { if let Err(err) = state.start_config(crate::config::get_config_dir()) {
panic!("failed to start config: {err}"); panic!("failed to start config: {err}");
} }
}); });
@ -166,7 +166,7 @@ impl State {
let (xwayland, channel) = XWayland::new(&display_handle); let (xwayland, channel) = XWayland::new(&display_handle);
let clone = display_handle.clone(); let clone = display_handle.clone();
tracing::debug!("inserting into loop"); tracing::debug!("inserting into loop");
let res = loop_handle.insert_source(channel, move |event, _, data| match event { let res = loop_handle.insert_source(channel, move |event, _, state| match event {
XWaylandEvent::Ready { XWaylandEvent::Ready {
connection, connection,
client, client,
@ -174,7 +174,7 @@ impl State {
display, display,
} => { } => {
let mut wm = X11Wm::start_wm( let mut wm = X11Wm::start_wm(
data.state.loop_handle.clone(), state.loop_handle.clone(),
clone.clone(), clone.clone(),
connection, connection,
client, client,
@ -192,13 +192,13 @@ impl State {
tracing::debug!("setting xwm and xdisplay"); tracing::debug!("setting xwm and xdisplay");
data.state.xwm = Some(wm); state.xwm = Some(wm);
data.state.xdisplay = Some(display); state.xdisplay = Some(display);
std::env::set_var("DISPLAY", format!(":{display}")); std::env::set_var("DISPLAY", format!(":{display}"));
} }
XWaylandEvent::Exited => { XWaylandEvent::Exited => {
data.state.xwm.take(); state.xwm.take();
} }
}); });
if let Err(err) = res { if let Err(err) = res {
@ -274,28 +274,16 @@ impl State {
/// This will continually reschedule `run` in the event loop if `condition` returns false. /// This will continually reschedule `run` in the event loop if `condition` returns false.
pub fn schedule<F1, F2>(&self, condition: F1, run: F2) pub fn schedule<F1, F2>(&self, condition: F1, run: F2)
where where
F1: Fn(&mut CalloopData) -> bool + 'static, F1: Fn(&mut Self) -> bool + 'static,
F2: FnOnce(&mut CalloopData) + 'static, F2: FnOnce(&mut Self) + 'static,
{ {
self.loop_handle.insert_idle(|data| { self.loop_handle.insert_idle(|state| {
Self::schedule_inner(data, condition, run); if !condition(state) {
}); state.schedule(condition, run);
} else {
run(state);
} }
/// Schedule something to be done when `condition` returns true.
fn schedule_inner<F1, F2>(data: &mut CalloopData, condition: F1, run: F2)
where
F1: Fn(&mut CalloopData) -> bool + 'static,
F2: FnOnce(&mut CalloopData) + 'static,
{
if !condition(data) {
data.state.loop_handle.insert_idle(|data| {
Self::schedule_inner(data, condition, run);
}); });
return;
}
run(data);
} }
pub fn shutdown(&self) { pub fn shutdown(&self) {
@ -304,11 +292,6 @@ impl State {
} }
} }
pub struct CalloopData {
pub display_handle: DisplayHandle,
pub state: State,
}
#[derive(Default)] #[derive(Default)]
pub struct ClientState { pub struct ClientState {
pub compositor_state: CompositorClientState, pub compositor_state: CompositorClientState,