portlight 0.0.2

Cross-platform window management for audio plugins
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::cell::{Cell, RefCell};
use std::cmp::Ordering;
use std::collections::{BinaryHeap, HashMap};
use std::rc::Rc;
use std::time::{Duration, Instant};

use crate::{EventLoop, Result};

pub type TimerId = usize;

pub struct TimerState {
    timer_id: TimerId,
    duration: Duration,
    event_loop: EventLoop,
    handler: RefCell<Box<dyn FnMut()>>,
}

impl TimerState {
    fn handle_timer(&self) -> Option<()> {
        self.handler.borrow_mut()();
        Some(())
    }

    pub fn repeat<F>(
        event_loop: &EventLoop,
        duration: Duration,
        handler: F,
    ) -> Result<Rc<TimerState>>
    where
        F: FnMut() + 'static,
    {
        let now = Instant::now();

        let timer_id = event_loop.state.timers.next_id.get();
        event_loop.state.timers.next_id.set(timer_id + 1);

        let state = Rc::new(TimerState {
            timer_id,
            duration,
            event_loop: event_loop.clone(),
            handler: RefCell::new(Box::new(handler)),
        });

        event_loop.state.timers.timers.borrow_mut().insert(timer_id, Rc::clone(&state));

        event_loop.state.timers.queue.borrow_mut().push(QueueEntry {
            time: now + duration,
            timer_id,
        });

        Ok(state)
    }

    pub fn cancel(&self) {
        let timers = &self.event_loop.state.timers;
        timers.timers.borrow_mut().remove(&self.timer_id);
    }
}

#[derive(Clone)]
struct QueueEntry {
    time: Instant,
    timer_id: TimerId,
}

impl PartialEq for QueueEntry {
    fn eq(&self, other: &Self) -> bool {
        self.time == other.time
    }
}

impl Eq for QueueEntry {}

impl PartialOrd for QueueEntry {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.time.cmp(&other.time).reverse())
    }
}

impl Ord for QueueEntry {
    fn cmp(&self, other: &Self) -> Ordering {
        self.time.cmp(&other.time).reverse()
    }
}

pub struct Timers {
    next_id: Cell<TimerId>,
    timers: RefCell<HashMap<usize, Rc<TimerState>>>,
    queue: RefCell<BinaryHeap<QueueEntry>>,
}

impl Timers {
    pub fn new() -> Timers {
        Timers {
            next_id: Cell::new(0),
            timers: RefCell::new(HashMap::new()),
            queue: RefCell::new(BinaryHeap::new()),
        }
    }

    pub fn next_time(&self) -> Option<Instant> {
        self.queue.borrow().peek().map(|e| e.time)
    }

    pub fn poll(&self) {
        let now = Instant::now();

        // Check with < and not <= so that we don't process a timer twice during this loop
        while self.next_time().map_or(false, |t| t < now) {
            let next = self.queue.borrow_mut().pop().unwrap();

            // If we don't find the timer in `self.timers`, it has been canceled
            let timer_state = self.timers.borrow().get(&next.timer_id).cloned();
            if let Some(timer_state) = timer_state {
                timer_state.handle_timer();

                // If we fall behind by more than one timer interval, reset the timer's phase
                let next_time = (next.time + timer_state.duration).max(now);

                self.queue.borrow_mut().push(QueueEntry {
                    time: next_time,
                    timer_id: next.timer_id,
                })
            }
        }
    }
}