webbind 0.1.44

Rust bindings for the web api, auto-generated from WebIDL
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
128

use super::*;

/// The FenceEvent dictionary.
#[derive(Clone, Debug, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct FenceEvent {
    inner: Any,
}

impl FromVal for FenceEvent {
    fn from_val(v: &Any) -> Self {
        FenceEvent { inner: v.clone() }
    }
    fn take_ownership(v: AnyHandle) -> Self {
        Self::from_val(&Any::take_ownership(v))
    }
    fn as_handle(&self) -> AnyHandle {
        self.inner.as_handle()
    }
}

impl core::ops::Deref for FenceEvent {
    type Target = Any;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl core::ops::DerefMut for FenceEvent {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}

impl AsRef<Any> for FenceEvent {
    fn as_ref(&self) -> &Any {
        &self.inner
    }
}

impl AsMut<Any> for FenceEvent {
    fn as_mut(&mut self) -> &mut Any {
        &mut self.inner
    }
}

impl From<FenceEvent> for Any {
    fn from(s: FenceEvent) -> Any {
        let handle = s.inner.as_handle();
        core::mem::forget(s);
        Any::take_ownership(handle)
    }
}

impl From<&FenceEvent> for Any {
    fn from(s: &FenceEvent) -> Any {
        s.inner.clone()
    }
}

impl FenceEvent {
    /// Getter of the `eventType` attribute.
    pub fn event_type(&self) -> JsString {
        self.inner.get("eventType").as_::<JsString>()
    }

    /// Setter of the `eventType` attribute.
    pub fn set_event_type(&mut self, value: &JsString) {
        self.inner.set("eventType", value);
    }
}
impl FenceEvent {
    /// Getter of the `eventData` attribute.
    pub fn event_data(&self) -> JsString {
        self.inner.get("eventData").as_::<JsString>()
    }

    /// Setter of the `eventData` attribute.
    pub fn set_event_data(&mut self, value: &JsString) {
        self.inner.set("eventData", value);
    }
}
impl FenceEvent {
    /// Getter of the `destination` attribute.
    pub fn destination(&self) -> TypedArray<FenceReportingDestination> {
        self.inner
            .get("destination")
            .as_::<TypedArray<FenceReportingDestination>>()
    }

    /// Setter of the `destination` attribute.
    pub fn set_destination(&mut self, value: &TypedArray<FenceReportingDestination>) {
        self.inner.set("destination", value);
    }
}
impl FenceEvent {
    /// Getter of the `crossOriginExposed` attribute.
    pub fn cross_origin_exposed(&self) -> bool {
        self.inner.get("crossOriginExposed").as_::<bool>()
    }

    /// Setter of the `crossOriginExposed` attribute.
    pub fn set_cross_origin_exposed(&mut self, value: bool) {
        self.inner.set("crossOriginExposed", value);
    }
}
impl FenceEvent {
    /// Getter of the `once` attribute.
    pub fn once(&self) -> bool {
        self.inner.get("once").as_::<bool>()
    }

    /// Setter of the `once` attribute.
    pub fn set_once(&mut self, value: bool) {
        self.inner.set("once", value);
    }
}
impl FenceEvent {
    /// Getter of the `destinationURL` attribute.
    pub fn destination_url(&self) -> JsString {
        self.inner.get("destinationURL").as_::<JsString>()
    }

    /// Setter of the `destinationURL` attribute.
    pub fn set_destination_url(&mut self, value: &JsString) {
        self.inner.set("destinationURL", value);
    }
}