rsciter 0.0.11

Unofficial Rust bindings for Sciter
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 crate::{api::*, bindings::*, Result};

pub trait DebugNotifications {
    fn output(&self, subsystem: DebugSubsystem, severity: DebugSeverity, text: String);
}

#[derive(Debug)]
pub enum DebugSubsystem {
    Dom,
    Css,
    Csss,
    Script,
    Unknown(i32),
}

impl From<OUTPUT_SUBSYTEMS> for DebugSubsystem {
    fn from(value: OUTPUT_SUBSYTEMS) -> Self {
        match value {
            OUTPUT_SUBSYTEMS::OT_DOM => Self::Dom,
            OUTPUT_SUBSYTEMS::OT_CSS => Self::Css,
            OUTPUT_SUBSYTEMS::OT_CSSS => Self::Csss,
            OUTPUT_SUBSYTEMS::OT_TIS => Self::Script,
            v => Self::Unknown(v.0),
        }
    }
}

#[derive(Debug)]
pub enum DebugSeverity {
    Info,
    Warning,
    Error,
    Unknown(i32),
}

impl From<OUTPUT_SEVERITY> for DebugSeverity {
    fn from(value: OUTPUT_SEVERITY) -> Self {
        match value {
            OUTPUT_SEVERITY::OS_INFO => Self::Info,
            OUTPUT_SEVERITY::OS_WARNING => Self::Warning,
            OUTPUT_SEVERITY::OS_ERROR => Self::Error,
            x => Self::Unknown(x.0),
        }
    }
}

#[must_use = "rsciter::DebugOutputGuard value should be alive until the end, or there will be no debug output!"]
pub struct DebugOutputGuard {
    #[allow(dead_code)]
    handler: Box<Inner>,
}

struct Inner(Box<dyn DebugNotifications>);

impl Drop for DebugOutputGuard {
    fn drop(&mut self) {
        if let Ok(api) = sapi() {
            let _ = api.setup_debug_output(None, std::ptr::null_mut(), None);
        }
        // now it's safe to drop handler
    }
}

impl<F> DebugNotifications for F
where
    F: Fn(DebugSubsystem, DebugSeverity, String),
{
    fn output(&self, subsystem: DebugSubsystem, severity: DebugSeverity, text: String) {
        self(subsystem, severity, text)
    }
}

pub fn setup_debug_output(output: impl DebugNotifications + 'static) -> Result<DebugOutputGuard> {
    let mut boxed = Box::new(Inner(Box::new(output)));
    let ptr = boxed.as_mut() as *const Inner as *mut _;

    sapi()?.setup_debug_output(None, ptr, Some(debug_thunk))?;

    Ok(DebugOutputGuard { handler: boxed })
}

unsafe extern "C" fn debug_thunk(
    param: LPVOID,
    subsystem: UINT,
    severity: UINT,
    text: LPCWSTR,
    text_length: UINT,
) {
    if param.is_null() {
        return;
    }

    let inner = &*(param as *const Inner);
    let data = std::slice::from_raw_parts(text, text_length as usize);
    let subsystem = OUTPUT_SUBSYTEMS(subsystem as i32).into();
    let severity = OUTPUT_SEVERITY(severity as i32).into();
    inner
        .0
        .output(subsystem, severity, String::from_utf16_lossy(data));
}