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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

use super::*;

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

impl FromVal for VideoConfiguration {
    fn from_val(v: &Any) -> Self {
        VideoConfiguration { 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 VideoConfiguration {
    type Target = Any;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

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

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

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

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

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

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

    /// Setter of the `contentType` attribute.
    pub fn set_content_type(&mut self, value: &JsString) {
        self.inner.set("contentType", value);
    }
}
impl VideoConfiguration {
    /// Getter of the `width` attribute.
    pub fn width(&self) -> u32 {
        self.inner.get("width").as_::<u32>()
    }

    /// Setter of the `width` attribute.
    pub fn set_width(&mut self, value: u32) {
        self.inner.set("width", value);
    }
}
impl VideoConfiguration {
    /// Getter of the `height` attribute.
    pub fn height(&self) -> u32 {
        self.inner.get("height").as_::<u32>()
    }

    /// Setter of the `height` attribute.
    pub fn set_height(&mut self, value: u32) {
        self.inner.set("height", value);
    }
}
impl VideoConfiguration {
    /// Getter of the `bitrate` attribute.
    pub fn bitrate(&self) -> u64 {
        self.inner.get("bitrate").as_::<u64>()
    }

    /// Setter of the `bitrate` attribute.
    pub fn set_bitrate(&mut self, value: u64) {
        self.inner.set("bitrate", value);
    }
}
impl VideoConfiguration {
    /// Getter of the `framerate` attribute.
    pub fn framerate(&self) -> f64 {
        self.inner.get("framerate").as_::<f64>()
    }

    /// Setter of the `framerate` attribute.
    pub fn set_framerate(&mut self, value: f64) {
        self.inner.set("framerate", value);
    }
}
impl VideoConfiguration {
    /// Getter of the `hasAlphaChannel` attribute.
    pub fn has_alpha_channel(&self) -> bool {
        self.inner.get("hasAlphaChannel").as_::<bool>()
    }

    /// Setter of the `hasAlphaChannel` attribute.
    pub fn set_has_alpha_channel(&mut self, value: bool) {
        self.inner.set("hasAlphaChannel", value);
    }
}
impl VideoConfiguration {
    /// Getter of the `hdrMetadataType` attribute.
    pub fn hdr_metadata_type(&self) -> HdrMetadataType {
        self.inner.get("hdrMetadataType").as_::<HdrMetadataType>()
    }

    /// Setter of the `hdrMetadataType` attribute.
    pub fn set_hdr_metadata_type(&mut self, value: &HdrMetadataType) {
        self.inner.set("hdrMetadataType", value);
    }
}
impl VideoConfiguration {
    /// Getter of the `colorGamut` attribute.
    pub fn color_gamut(&self) -> ColorGamut {
        self.inner.get("colorGamut").as_::<ColorGamut>()
    }

    /// Setter of the `colorGamut` attribute.
    pub fn set_color_gamut(&mut self, value: &ColorGamut) {
        self.inner.set("colorGamut", value);
    }
}
impl VideoConfiguration {
    /// Getter of the `transferFunction` attribute.
    pub fn transfer_function(&self) -> TransferFunction {
        self.inner.get("transferFunction").as_::<TransferFunction>()
    }

    /// Setter of the `transferFunction` attribute.
    pub fn set_transfer_function(&mut self, value: &TransferFunction) {
        self.inner.set("transferFunction", value);
    }
}
impl VideoConfiguration {
    /// Getter of the `scalabilityMode` attribute.
    pub fn scalability_mode(&self) -> JsString {
        self.inner.get("scalabilityMode").as_::<JsString>()
    }

    /// Setter of the `scalabilityMode` attribute.
    pub fn set_scalability_mode(&mut self, value: &JsString) {
        self.inner.set("scalabilityMode", value);
    }
}
impl VideoConfiguration {
    /// Getter of the `spatialScalability` attribute.
    pub fn spatial_scalability(&self) -> bool {
        self.inner.get("spatialScalability").as_::<bool>()
    }

    /// Setter of the `spatialScalability` attribute.
    pub fn set_spatial_scalability(&mut self, value: bool) {
        self.inner.set("spatialScalability", value);
    }
}