baseview 0.4.0

Low-level windowing system geared towards making audio plugin UIs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use dispatch2::DispatchQueue;
use objc2::rc::Weak;
use objc2::{MainThreadMarker, Message};
use std::mem::ManuallyDrop;
use std::time::Duration;

// This is like MainThreadBound<Weak<T>>, but uses async dispatch
pub struct MainThreadBoundWeak<T: Message + 'static>(ManuallyDrop<Weak<T>>);

// SAFETY: The inner value is guaranteed to originate from the main thread
// because T is Message.
//
// Finally, the value is dropped on the main thread in `Drop`.
unsafe impl<T: Message + 'static> Send for MainThreadBoundWeak<T> {}

// SAFETY: We do not provide access to the inner value.
unsafe impl<T: Message + 'static> Sync for MainThreadBoundWeak<T> {}

impl<T: Message + 'static> Drop for MainThreadBoundWeak<T> {
    #[inline]
    fn drop(&mut self) {
        if MainThreadMarker::new().is_some() {
            // SAFETY: The value is dropped on the main thread, which is
            // the same thread that it originated from (guaranteed by
            // `new` taking `MainThreadMarker`).
            //
            // Additionally, the value is never used again after this
            // point.
            unsafe { ManuallyDrop::drop(&mut self.0) };
        } else {
            let weak = MTWrapper(unsafe { ManuallyDrop::take(&mut self.0) });

            DispatchQueue::main().exec_async(move || {
                drop(weak);
            });
        }
    }
}

impl<T: Message + 'static> Clone for MainThreadBoundWeak<T> {
    fn clone(&self) -> Self {
        // This is actually safe to do off of the main thread
        Self(ManuallyDrop::new(Weak::clone(&self.0)))
    }
}

impl<T: Message + 'static> MainThreadBoundWeak<T> {
    pub fn new(inner: Weak<T>) -> Self {
        Self(ManuallyDrop::new(inner))
    }

    pub fn use_on_main_thread_after(
        &self, duration: Duration, handler: impl FnOnce(Weak<T>) + Send + 'static,
    ) {
        if duration.is_zero() {
            self.use_on_main_thread(handler);
            return;
        }

        let Ok(time) = duration.try_into() else {
            return;
        };

        let handler = {
            let handle = MTWrapper(Weak::clone(&self.0));
            let handler = MTWrapper::new_handler(handler);
            move || handler(handle)
        };

        let _ = DispatchQueue::main().after(time, handler);
    }

    pub fn use_on_main_thread(&self, handler: impl FnOnce(Weak<T>) + Send + 'static) {
        if MainThreadMarker::new().is_some() {
            handler(Weak::clone(&self.0));
            return;
        }

        let handler = {
            let handle = MTWrapper(Weak::clone(&self.0));
            let handler = MTWrapper::new_handler(handler);
            move || handler(handle)
        };

        DispatchQueue::main().exec_async(handler);
    }
}

struct MTWrapper<T>(Weak<T>);

impl<T> MTWrapper<T> {
    pub fn new_handler(
        handler: impl FnOnce(Weak<T>) + Send + 'static,
    ) -> impl FnOnce(MTWrapper<T>) + Send + 'static {
        |h| handler(h.0)
    }
}

unsafe impl<T> Send for MTWrapper<T> {}
unsafe impl<T> Sync for MTWrapper<T> {}