cranpose-core 0.0.58

Core runtime for a Jetpack Compose inspired UI framework in Rust
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

use std::cell::RefCell;
use std::rc::Rc;

use crate::{Composer, ComposerCore};

// Thread-local stack of Composer handles (safe, no raw pointers).
thread_local! {
    static COMPOSER_STACK: RefCell<Vec<Rc<ComposerCore>>> = const { RefCell::new(Vec::new()) };
}

/// Guard that pops the composer stack on drop.
#[must_use = "ComposerScopeGuard pops the composer stack on drop"]
pub struct ComposerScopeGuard;

impl Drop for ComposerScopeGuard {
    fn drop(&mut self) {
        COMPOSER_STACK.with(|stack| {
            let mut stack = stack.borrow_mut();
            stack.pop();
        });
    }
}

/// Pushes the composer onto the thread-local stack for the duration of the scope.
/// Returns a guard that will pop it on drop.
pub fn enter(composer: &Composer) -> ComposerScopeGuard {
    COMPOSER_STACK.with(|stack| {
        stack.borrow_mut().push(composer.clone_core());
    });
    ComposerScopeGuard
}

/// Access the current composer from the thread-local stack.
///
/// # Panics
/// Panics if there is no active composer.
pub fn with_composer<R>(f: impl FnOnce(&Composer) -> R) -> R {
    COMPOSER_STACK.with(|stack| {
        let core = stack
            .borrow()
            .last()
            .expect("with_composer: no active composer")
            .clone();
        let composer = Composer::from_core(core);
        f(&composer)
    })
}

/// Try to access the current composer from the thread-local stack.
/// Returns None if there is no active composer.
pub fn try_with_composer<R>(f: impl FnOnce(&Composer) -> R) -> Option<R> {
    COMPOSER_STACK.with(|stack| {
        let core = stack.borrow().last()?.clone();
        let composer = Composer::from_core(core);
        Some(f(&composer))
    })
}