autocommit 2022-01-25 16:45:44 CET

src/tasks/backend.rs

@@ -0,0 +1,55 @@
+use crate::backend::{BackendEvent, Output, Seat};
+use crate::state::SeatData;
+use crate::tasks::output::OutputHandler;
+use crate::tasks::seat::SeatHandler;
+use crate::utils::asyncevent::AsyncEvent;
+use crate::State;
+use std::rc::Rc;
+
+pub struct BackendEventHandler {
+    pub state: Rc<State>,
+}
+
+impl BackendEventHandler {
+    pub async fn handle_events(&mut self) {
+        loop {
+            let event = self.state.backend_events.pop().await;
+            self.handle_event(event);
+        }
+    }
+
+    fn handle_event(&mut self, event: BackendEvent) {
+        match event {
+            BackendEvent::NewOutput(output) => self.handle_new_output(output),
+            BackendEvent::NewSeat(seat) => self.handle_new_seat(seat),
+        }
+    }
+
+    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);
+    }
+
+    fn handle_new_seat(&mut self, seat: Rc<dyn Seat>) {
+        let id = seat.id();
+        let tree_changed = Rc::new(AsyncEvent::default());
+        let oh = SeatHandler {
+            state: self.state.clone(),
+            seat,
+            tree_changed: tree_changed.clone(),
+        };
+        let handler = self.state.eng.spawn(oh.handle());
+        self.state.seats.borrow_mut().insert(
+            id,
+            SeatData {
+                handler,
+                tree_changed,
+            },
+        );
+    }
+}

src/tasks/mod.rs

@@ -0,0 +1,19 @@
+mod backend;
+mod output;
+mod seat;
+mod slow_clients;
+
+use crate::tasks::backend::BackendEventHandler;
+use crate::tasks::slow_clients::SlowClientHandler;
+use crate::State;
+use std::rc::Rc;
+
+pub async fn handle_backend_events(state: Rc<State>) {
+    let mut beh = BackendEventHandler { state };
+    beh.handle_events().await;
+}
+
+pub async fn handle_slow_clients(state: Rc<State>) {
+    let mut sch = SlowClientHandler { state };
+    sch.handle_events().await;
+}

src/tasks/output.rs

@@ -0,0 +1,66 @@
+use crate::backend::Output;
+use crate::ifs::wl_output::WlOutputGlobal;
+use crate::tree::{Node, OutputNode, WorkspaceNode};
+use crate::utils::asyncevent::AsyncEvent;
+use crate::utils::clonecell::CloneCell;
+use crate::State;
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+pub struct OutputHandler {
+    pub state: Rc<State>,
+    pub output: Rc<dyn Output>,
+}
+
+impl OutputHandler {
+    pub 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 {
+            display: self.state.root.clone(),
+            id: self.state.node_ids.next(),
+            backend: self.output.clone(),
+            workspaces: RefCell::new(vec![]),
+            position: Cell::new(Default::default()),
+            workspace: CloneCell::new(None),
+        });
+        let workspace = Rc::new(WorkspaceNode {
+            id: self.state.node_ids.next(),
+            output: CloneCell::new(on.clone()),
+            container: Default::default(),
+            floaters: Default::default(),
+        });
+        on.workspace.set(Some(workspace));
+        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);
+        self.state.outputs.set(self.output.id(), global.clone());
+        let mut width = 0;
+        let mut height = 0;
+        loop {
+            if self.output.removed() {
+                break;
+            }
+            let new_width = self.output.width();
+            let new_height = self.output.height();
+            if new_width != width || new_height != height {
+                width = new_width;
+                height = new_height;
+                on.clone().change_size(width, height);
+            }
+            global.update_properties();
+            ae.triggered().await;
+        }
+        self.state.outputs.remove(&self.output.id());
+        let _ = self.state.globals.remove(&self.state, name);
+        self.state
+            .output_handlers
+            .borrow_mut()
+            .remove(&self.output.id());
+        self.state.root.outputs.remove(&self.output.id());
+    }
+}

src/tasks/seat.rs

@@ -0,0 +1,52 @@
+use crate::backend::Seat;
+use crate::ifs::wl_seat::WlSeatGlobal;
+use crate::utils::asyncevent::AsyncEvent;
+use crate::State;
+use std::rc::Rc;
+
+pub struct SeatHandler {
+    pub state: Rc<State>,
+    pub seat: Rc<dyn Seat>,
+    pub tree_changed: Rc<AsyncEvent>,
+}
+
+impl SeatHandler {
+    pub 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));
+        let _tree_changed = self
+            .state
+            .eng
+            .spawn(tree_changed(global.clone(), self.tree_changed.clone()));
+        let mut _node = self.state.seat_queue.add_last(global.clone());
+        self.state.add_global(&global);
+        loop {
+            if self.seat.removed() {
+                break;
+            }
+            let mut any_events = false;
+            while let Some(event) = self.seat.event() {
+                global.event(event);
+                any_events = true;
+            }
+            if any_events {
+                _node = self.state.seat_queue.add_last(global.clone());
+            }
+            ae.triggered().await;
+        }
+        let _ = self.state.globals.remove(&self.state, name);
+        self.state.seats.borrow_mut().remove(&self.seat.id());
+    }
+}
+
+async fn tree_changed(global: Rc<WlSeatGlobal>, tree_changed: Rc<AsyncEvent>) {
+    loop {
+        tree_changed.triggered().await;
+        global.tree_changed();
+    }
+}

src/tasks/slow_clients.rs

@@ -0,0 +1,15 @@
+use crate::State;
+use std::rc::Rc;
+
+pub struct SlowClientHandler {
+    pub state: Rc<State>,
+}
+
+impl SlowClientHandler {
+    pub async fn handle_events(&mut self) {
+        loop {
+            let client = self.state.slow_clients.pop().await;
+            client.check_queue_size().await;
+        }
+    }
+}