Merge branch 'master' into dart-vdd-prototype

Author: Dampfwalze

examples/monitor_control.py

@@ -131,12 +131,15 @@
 # you can ask to be notified.
 # this represents the complete current state of the driver
 #
-# DriverClient.receive(Callable[list[Monitor], None])
+# DriverClient.receive(Optional[Callable[list[Monitor], None]])
 client.receive(lambda d: print(d))
 # one way to use this might be to auto update your driver instance
 def set_monitors(data):
     client.monitors = data
+# calling it on a new callback will cancel the old one and set the new one
 client.receive(set_monitors)
+# calling it with no args will cancel the current receiver
+client.receive()
 
 # gets latest states from driver
 #

rust/Cargo.lock

@@ -10,9 +10,5 @@ crate-type = ["cdylib"]
 pyo3 = "0.21.1"
 driver-ipc = { path = "../../driver-ipc" }
 
-[dependencies.windows]
-version = "0.54.0"
-features = ["Win32_Foundation", "Win32_System_Threading"]
-
 [lints]
 workspace = true

rust/bindings/pyvdd/Cargo.toml

@@ -5,34 +5,22 @@
 
 mod utils;
 
+use std::fmt::Debug;
 use std::{
     borrow::{Borrow, Cow},
     collections::HashSet,
     fmt::Display,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
+    sync::atomic::{AtomicBool, Ordering},
 };
-use std::{fmt::Debug, sync::Mutex};
 
-use driver_ipc::{
-    ClientCommand, Dimen, DriverClient, EventCommand, Id, Mode, Monitor, RefreshRate,
-};
+use driver_ipc::{Dimen, DriverClient, EventCommand, Id, Mode, Monitor, RefreshRate};
 use pyo3::prelude::*;
 use pyo3::{
     exceptions::{PyIndexError, PyRuntimeError, PyTypeError},
     pyclass::boolean_struct::False,
     types::{DerefToPyAny, PyList, PyLong},
     DowncastIntoError, PyClass, PyTypeCheck,
 };
-use windows::Win32::{
-    Foundation::{DuplicateHandle, DUPLICATE_SAME_ACCESS, HANDLE},
-    System::{
-        Threading::{GetCurrentProcess, GetCurrentThread},
-        IO::CancelSynchronousIo,
-    },
-};
 
 use self::utils::IntoPyErr as _;
 
@@ -336,7 +324,6 @@ impl IntoPyListIter for Py<PyTypedList> {
 #[pyo3(name = "DriverClient")]
 struct PyDriverClient {
     client: DriverClient,
-    thread_registry: Arc<Mutex<Option<HANDLE>>>,
     /// The list of monitors
     /// Sig: list[Monitor]
     #[pyo3(get)]
@@ -358,11 +345,7 @@ impl PyDriverClient {
 
         let monitors = state_to_pytypedlist(py, client.monitors())?;
 
-        let slf = Self {
-            client,
-            monitors,
-            thread_registry: Arc::new(Mutex::new(None)),
-        };
+        let slf = Self { client, monitors };
 
         Ok(slf)
     }
@@ -417,58 +400,28 @@ impl PyDriverClient {
     }
 
     /// Get notified of other clients changing driver configuration
-    /// Sig: receive(Callable[list[Monitor], None])
-    fn receive(&self, callback: PyObject) {
-        // cancel the receiver internally if called again
-        {
-            let lock = self.thread_registry.lock().unwrap().take();
-            if let Some(thread) = lock {
-                unsafe {
-                    _ = CancelSynchronousIo(thread);
-                }
-            }
+    /// Sig: receive(Optional[Callable[list[Monitor], None]])
+    fn receive(&self, callback: Option<PyObject>) {
+        if let Some(callback) = callback {
+            self.client.set_event_receiver(move |cmd| {
+                let EventCommand::Changed(data) = cmd else {
+                    unreachable!()
+                };
+
+                Python::with_gil(|py| {
+                    let state = state_to_pylist(py, &data);
+                    let Ok(state) = state else {
+                        return;
+                    };
+
+                    if let Err(e) = callback.call1(py, (state,)) {
+                        e.print(py);
+                    }
+                });
+            });
+        } else {
+            self.client.terminate_receiver();
         }
-
-        let registry = self.thread_registry.clone();
-        self.client.set_receiver(
-            // init - store thread handle for later
-            Some(move || {
-                let mut lock = registry.lock().unwrap();
-
-                let pseudo_handle = unsafe { GetCurrentThread() };
-                let current_process = unsafe { GetCurrentProcess() };
-
-                let mut thread_handle = HANDLE::default();
-                unsafe {
-                    _ = DuplicateHandle(
-                        current_process,
-                        pseudo_handle,
-                        current_process,
-                        &mut thread_handle,
-                        0,
-                        false,
-                        DUPLICATE_SAME_ACCESS,
-                    );
-                }
-
-                *lock = Some(thread_handle);
-            }),
-            // cb
-            move |command| {
-                if let ClientCommand::Event(EventCommand::Changed(data)) = command {
-                    Python::with_gil(|py| {
-                        let state = state_to_pylist(py, &data);
-                        let Ok(state) = state else {
-                            return;
-                        };
-
-                        if let Err(e) = callback.call1(py, (state,)) {
-                            e.print(py);
-                        }
-                    });
-                }
-            },
-        );
     }
 
     /// Find a monitor by Id

rust/bindings/pyvdd/src/lib.rs

@@ -10,7 +10,7 @@ thiserror = "1.0.58"
 owo-colors = "4.0.0"
 serde_json = "1.0.114"
 windows = { version = "0.54.0", features = ["Win32_Foundation"] }
-win-pipes = { git = "https://github.com/MolotovCherry/WinPipes-rs" }
 lazy_format = "2.0.3"
 joinery = "3.1.0"
 winreg = "0.52.0"
+tokio = { version = "1.37.0", features = ["full"] }