140 lines
4.2 KiB
Rust
140 lines
4.2 KiB
Rust
use crate::backend::{BackendEvent, Output, Seat};
|
|
use crate::ifs::wl_output::WlOutputGlobal;
|
|
use crate::ifs::wl_seat::WlSeatGlobal;
|
|
use crate::tree::{NodeCommon, NodeExtents, OutputNode};
|
|
use crate::utils::asyncevent::AsyncEvent;
|
|
use crate::State;
|
|
use std::cell::{Cell, RefCell};
|
|
use std::rc::Rc;
|
|
|
|
pub async fn handle_backend_events(state: Rc<State>) {
|
|
let mut beh = BackendEventHandler { state };
|
|
beh.handle_events().await;
|
|
}
|
|
|
|
struct BackendEventHandler {
|
|
state: Rc<State>,
|
|
}
|
|
|
|
impl BackendEventHandler {
|
|
async fn handle_events(&mut self) {
|
|
loop {
|
|
let event = self.state.backend_events.pop().await;
|
|
self.handle_event(event).await;
|
|
}
|
|
}
|
|
|
|
async fn handle_event(&mut self, event: BackendEvent) {
|
|
match event {
|
|
BackendEvent::NewOutput(output) => self.handle_new_output(output).await,
|
|
BackendEvent::NewSeat(seat) => self.handle_new_seat(seat).await,
|
|
}
|
|
}
|
|
|
|
async fn handle_new_output(&mut self, output: Rc<dyn Output>) {
|
|
let id = output.id();
|
|
let oh = OutputHandler {
|
|
state: self.state.clone(),
|
|
output,
|
|
};
|
|
let future = self.state.eng.spawn(oh.handle());
|
|
self.state.output_handlers.borrow_mut().insert(id, future);
|
|
}
|
|
|
|
async fn handle_new_seat(&mut self, seat: Rc<dyn Seat>) {
|
|
let id = seat.id();
|
|
let oh = SeatHandler {
|
|
state: self.state.clone(),
|
|
seat,
|
|
};
|
|
let future = self.state.eng.spawn(oh.handle());
|
|
self.state.seat_handlers.borrow_mut().insert(id, future);
|
|
}
|
|
}
|
|
|
|
struct OutputHandler {
|
|
state: Rc<State>,
|
|
output: Rc<dyn Output>,
|
|
}
|
|
|
|
impl OutputHandler {
|
|
async fn handle(self) {
|
|
let ae = Rc::new(AsyncEvent::default());
|
|
{
|
|
let ae = ae.clone();
|
|
self.output.on_change(Rc::new(move || ae.trigger()));
|
|
}
|
|
let on = Rc::new(OutputNode {
|
|
common: NodeCommon {
|
|
extents: Cell::new(NodeExtents {
|
|
x: 0,
|
|
y: 0,
|
|
width: self.output.width(),
|
|
height: self.output.height(),
|
|
}),
|
|
id: self.state.node_ids.next(),
|
|
parent: Some(self.state.root.clone()),
|
|
floating_outputs: RefCell::new(Default::default()),
|
|
},
|
|
backend: self.output.clone(),
|
|
child: RefCell::new(None),
|
|
floating: Default::default(),
|
|
});
|
|
self.state.root.outputs.set(self.output.id(), on.clone());
|
|
let name = self.state.globals.name();
|
|
let global = Rc::new(WlOutputGlobal::new(name, &self.output));
|
|
self.state.add_global(&global).await;
|
|
self.state.outputs.set(self.output.id(), global.clone());
|
|
loop {
|
|
if self.output.removed() {
|
|
break;
|
|
}
|
|
on.common.extents.set(NodeExtents {
|
|
x: 0,
|
|
y: 0,
|
|
width: self.output.width(),
|
|
height: self.output.height(),
|
|
});
|
|
global.update_properties().await;
|
|
ae.triggered().await;
|
|
}
|
|
self.state.outputs.remove(&self.output.id());
|
|
let _ = self.state.globals.remove(&self.state, name).await;
|
|
self.state
|
|
.output_handlers
|
|
.borrow_mut()
|
|
.remove(&self.output.id());
|
|
}
|
|
}
|
|
|
|
struct SeatHandler {
|
|
state: Rc<State>,
|
|
seat: Rc<dyn Seat>,
|
|
}
|
|
|
|
impl SeatHandler {
|
|
async fn handle(self) {
|
|
let ae = Rc::new(AsyncEvent::default());
|
|
{
|
|
let ae = ae.clone();
|
|
self.seat.on_change(Rc::new(move || ae.trigger()));
|
|
}
|
|
let name = self.state.globals.name();
|
|
let global = Rc::new(WlSeatGlobal::new(name, &self.state, &self.seat));
|
|
self.state.add_global(&global).await;
|
|
loop {
|
|
if self.seat.removed() {
|
|
break;
|
|
}
|
|
while let Some(event) = self.seat.event() {
|
|
global.event(event).await;
|
|
}
|
|
ae.triggered().await;
|
|
}
|
|
let _ = self.state.globals.remove(&self.state, name).await;
|
|
self.state
|
|
.seat_handlers
|
|
.borrow_mut()
|
|
.remove(&self.seat.id());
|
|
}
|
|
}
|