skia-safe 0.97.0

Safe Skia Bindings for Rust
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

use std::{cell::UnsafeCell, fmt};

use crate::prelude::*;
use skia_bindings::{self as sb, SkRecorder};

pub type Type = skia_bindings::SkRecorder_Type;
variant_name!(Type::CPU);

pub trait Recorder: sealed::AsRecorderRef + fmt::Debug {
    fn ty(&self) -> Type;
    // TODO:
    // fn cpu_recorder(&mut self) -> &mut cpu::Recorder;
}

pub(crate) mod sealed {
    pub trait AsRecorderRef {
        fn as_recorder_ref(&mut self) -> &mut super::RecorderRef;
    }
}

#[repr(transparent)]
pub struct RecorderRef(UnsafeCell<SkRecorder>);

impl NativeAccess for RecorderRef {
    type Native = SkRecorder;

    fn native(&self) -> &SkRecorder {
        unsafe { &*self.0.get() }
    }

    fn native_mut(&mut self) -> &mut SkRecorder {
        unsafe { &mut (*self.0.get()) }
    }
}

impl fmt::Debug for RecorderRef {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Recorder")
            .field("type", &self.ty())
            .finish()
    }
}

impl RecorderRef {
    #[allow(unused)] // ... in non-gpu builds.
    pub(crate) fn from_ref_mut(native: &mut SkRecorder) -> &mut Self {
        unsafe { transmute_ref_mut(native) }
    }
}

impl Recorder for RecorderRef {
    fn ty(&self) -> Type {
        let mut ty = Type::CPU;
        unsafe {
            sb::C_SkRecorder_type(self.native(), &mut ty);
        }
        ty
    }
}

impl sealed::AsRecorderRef for RecorderRef {
    fn as_recorder_ref(&mut self) -> &mut RecorderRef {
        self
    }
}

#[cfg(test)]
mod tests {
    use super::{Recorder, RecorderRef};

    #[allow(deref_nullptr)]
    fn _passing_the_different_kinds_of_recorder_compiles() {
        test(None);
        test(Some(owned_recorder()));
        test(Some(cpu_recorder()));

        fn test(_recorder: Option<&mut dyn Recorder>) {}

        fn owned_recorder() -> &'static mut RecorderRef {
            unsafe { &mut *std::ptr::null_mut() }
        }

        fn cpu_recorder() -> &'static mut crate::cpu::Recorder<'static> {
            unsafe { &mut *std::ptr::null_mut() }
        }
    }
}