1#![allow(non_camel_case_types,non_upper_case_globals,unsafe_op_in_unsafe_fn,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::enum_variant_names,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]
4
5use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
6use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
7use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
8use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
9use crate::import::base::*;
10
11pub use self::HTMLSourceElement_Binding::{Wrap, HTMLSourceElementMethods, GetProtoObject, GetConstructorObject, DefineDOMInterface};
12pub mod HTMLSourceElement_Binding {
13use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
14use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
15use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
16use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
17use crate::import::module::*;
18
19unsafe extern "C" fn get_src<D: DomTypes>
20(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
21 let mut result = false;
22 wrap_panic(&mut || result = (|| {
23 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24 let this = &*(this as *const D::HTMLSourceElement);
25 <D as DomHelpers<D>>::push_new_element_queue();
26
27 let result: USVString = this.Src();
28 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
29
30
31 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
32 return true;
33 })());
34 result
35}
36
37unsafe extern "C" fn set_src<D: DomTypes>
38(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
39 let mut result = false;
40 wrap_panic(&mut || result = (|| {
41 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
42 let this = &*(this as *const D::HTMLSourceElement);
43 let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
44 Ok(ConversionResult::Success(value)) => value,
45 Ok(ConversionResult::Failure(error)) => {
46 throw_type_error(cx.raw_cx(), &error);
47 return false;
48
49 }
50 _ => {
51 return false;
52
53 },
54 }
55 ;
56 <D as DomHelpers<D>>::push_new_element_queue();
57
58 let result: () = this.SetSrc(arg0);
59 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
60
61
62 true
63 })());
64 result
65}
66
67
68static src_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
69
70pub(crate) fn init_src_getterinfo<D: DomTypes>() {
71 src_getterinfo.set(JSJitInfo {
72 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
73 getter: Some(get_src::<D>)
74 },
75 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
76 protoID: PrototypeList::ID::HTMLSourceElement as u16,
77 },
78 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
79 _bitfield_align_1: [],
80 _bitfield_1: __BindgenBitfieldUnit::new(
81 new_jsjitinfo_bitfield_1!(
82 JSJitInfo_OpType::Getter as u8,
83 JSJitInfo_AliasSet::AliasEverything as u8,
84 JSValueType::JSVAL_TYPE_STRING as u8,
85 true,
86 false,
87 false,
88 false,
89 false,
90 false,
91 0,
92 ).to_ne_bytes()
93 ),
94});
95}
96static src_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
97
98pub(crate) fn init_src_setterinfo<D: DomTypes>() {
99 src_setterinfo.set(JSJitInfo {
100 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
101 setter: Some(set_src::<D>)
102 },
103 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
104 protoID: PrototypeList::ID::HTMLSourceElement as u16,
105 },
106 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
107 _bitfield_align_1: [],
108 _bitfield_1: __BindgenBitfieldUnit::new(
109 new_jsjitinfo_bitfield_1!(
110 JSJitInfo_OpType::Setter as u8,
111 JSJitInfo_AliasSet::AliasEverything as u8,
112 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
113 false,
114 false,
115 false,
116 false,
117 false,
118 false,
119 0,
120 ).to_ne_bytes()
121 ),
122});
123}
124unsafe extern "C" fn get_type<D: DomTypes>
125(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
126 let mut result = false;
127 wrap_panic(&mut || result = (|| {
128 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
129 let this = &*(this as *const D::HTMLSourceElement);
130 <D as DomHelpers<D>>::push_new_element_queue();
131
132 let result: DOMString = this.Type();
133 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
134
135
136 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
137 return true;
138 })());
139 result
140}
141
142unsafe extern "C" fn set_type<D: DomTypes>
143(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
144 let mut result = false;
145 wrap_panic(&mut || result = (|| {
146 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
147 let this = &*(this as *const D::HTMLSourceElement);
148 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
149 Ok(ConversionResult::Success(value)) => value,
150 Ok(ConversionResult::Failure(error)) => {
151 throw_type_error(cx.raw_cx(), &error);
152 return false;
153
154 }
155 _ => {
156 return false;
157
158 },
159 }
160 ;
161 <D as DomHelpers<D>>::push_new_element_queue();
162
163 let result: () = this.SetType(arg0);
164 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
165
166
167 true
168 })());
169 result
170}
171
172
173static type_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
174
175pub(crate) fn init_type_getterinfo<D: DomTypes>() {
176 type_getterinfo.set(JSJitInfo {
177 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
178 getter: Some(get_type::<D>)
179 },
180 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
181 protoID: PrototypeList::ID::HTMLSourceElement as u16,
182 },
183 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
184 _bitfield_align_1: [],
185 _bitfield_1: __BindgenBitfieldUnit::new(
186 new_jsjitinfo_bitfield_1!(
187 JSJitInfo_OpType::Getter as u8,
188 JSJitInfo_AliasSet::AliasEverything as u8,
189 JSValueType::JSVAL_TYPE_STRING as u8,
190 true,
191 false,
192 false,
193 false,
194 false,
195 false,
196 0,
197 ).to_ne_bytes()
198 ),
199});
200}
201static type_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
202
203pub(crate) fn init_type_setterinfo<D: DomTypes>() {
204 type_setterinfo.set(JSJitInfo {
205 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
206 setter: Some(set_type::<D>)
207 },
208 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
209 protoID: PrototypeList::ID::HTMLSourceElement as u16,
210 },
211 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
212 _bitfield_align_1: [],
213 _bitfield_1: __BindgenBitfieldUnit::new(
214 new_jsjitinfo_bitfield_1!(
215 JSJitInfo_OpType::Setter as u8,
216 JSJitInfo_AliasSet::AliasEverything as u8,
217 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
218 false,
219 false,
220 false,
221 false,
222 false,
223 false,
224 0,
225 ).to_ne_bytes()
226 ),
227});
228}
229unsafe extern "C" fn get_srcset<D: DomTypes>
230(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
231 let mut result = false;
232 wrap_panic(&mut || result = (|| {
233 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
234 let this = &*(this as *const D::HTMLSourceElement);
235 <D as DomHelpers<D>>::push_new_element_queue();
236
237 let result: USVString = this.Srcset();
238 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
239
240
241 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
242 return true;
243 })());
244 result
245}
246
247unsafe extern "C" fn set_srcset<D: DomTypes>
248(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
249 let mut result = false;
250 wrap_panic(&mut || result = (|| {
251 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
252 let this = &*(this as *const D::HTMLSourceElement);
253 let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
254 Ok(ConversionResult::Success(value)) => value,
255 Ok(ConversionResult::Failure(error)) => {
256 throw_type_error(cx.raw_cx(), &error);
257 return false;
258
259 }
260 _ => {
261 return false;
262
263 },
264 }
265 ;
266 <D as DomHelpers<D>>::push_new_element_queue();
267
268 let result: () = this.SetSrcset(arg0);
269 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
270
271
272 true
273 })());
274 result
275}
276
277
278static srcset_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
279
280pub(crate) fn init_srcset_getterinfo<D: DomTypes>() {
281 srcset_getterinfo.set(JSJitInfo {
282 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
283 getter: Some(get_srcset::<D>)
284 },
285 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
286 protoID: PrototypeList::ID::HTMLSourceElement as u16,
287 },
288 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
289 _bitfield_align_1: [],
290 _bitfield_1: __BindgenBitfieldUnit::new(
291 new_jsjitinfo_bitfield_1!(
292 JSJitInfo_OpType::Getter as u8,
293 JSJitInfo_AliasSet::AliasEverything as u8,
294 JSValueType::JSVAL_TYPE_STRING as u8,
295 true,
296 false,
297 false,
298 false,
299 false,
300 false,
301 0,
302 ).to_ne_bytes()
303 ),
304});
305}
306static srcset_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
307
308pub(crate) fn init_srcset_setterinfo<D: DomTypes>() {
309 srcset_setterinfo.set(JSJitInfo {
310 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
311 setter: Some(set_srcset::<D>)
312 },
313 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
314 protoID: PrototypeList::ID::HTMLSourceElement as u16,
315 },
316 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
317 _bitfield_align_1: [],
318 _bitfield_1: __BindgenBitfieldUnit::new(
319 new_jsjitinfo_bitfield_1!(
320 JSJitInfo_OpType::Setter as u8,
321 JSJitInfo_AliasSet::AliasEverything as u8,
322 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
323 false,
324 false,
325 false,
326 false,
327 false,
328 false,
329 0,
330 ).to_ne_bytes()
331 ),
332});
333}
334unsafe extern "C" fn get_sizes<D: DomTypes>
335(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
336 let mut result = false;
337 wrap_panic(&mut || result = (|| {
338 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
339 let this = &*(this as *const D::HTMLSourceElement);
340 <D as DomHelpers<D>>::push_new_element_queue();
341
342 let result: DOMString = this.Sizes();
343 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
344
345
346 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
347 return true;
348 })());
349 result
350}
351
352unsafe extern "C" fn set_sizes<D: DomTypes>
353(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
354 let mut result = false;
355 wrap_panic(&mut || result = (|| {
356 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
357 let this = &*(this as *const D::HTMLSourceElement);
358 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
359 Ok(ConversionResult::Success(value)) => value,
360 Ok(ConversionResult::Failure(error)) => {
361 throw_type_error(cx.raw_cx(), &error);
362 return false;
363
364 }
365 _ => {
366 return false;
367
368 },
369 }
370 ;
371 <D as DomHelpers<D>>::push_new_element_queue();
372
373 let result: () = this.SetSizes(arg0);
374 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
375
376
377 true
378 })());
379 result
380}
381
382
383static sizes_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
384
385pub(crate) fn init_sizes_getterinfo<D: DomTypes>() {
386 sizes_getterinfo.set(JSJitInfo {
387 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
388 getter: Some(get_sizes::<D>)
389 },
390 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
391 protoID: PrototypeList::ID::HTMLSourceElement as u16,
392 },
393 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
394 _bitfield_align_1: [],
395 _bitfield_1: __BindgenBitfieldUnit::new(
396 new_jsjitinfo_bitfield_1!(
397 JSJitInfo_OpType::Getter as u8,
398 JSJitInfo_AliasSet::AliasEverything as u8,
399 JSValueType::JSVAL_TYPE_STRING as u8,
400 true,
401 false,
402 false,
403 false,
404 false,
405 false,
406 0,
407 ).to_ne_bytes()
408 ),
409});
410}
411static sizes_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
412
413pub(crate) fn init_sizes_setterinfo<D: DomTypes>() {
414 sizes_setterinfo.set(JSJitInfo {
415 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
416 setter: Some(set_sizes::<D>)
417 },
418 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
419 protoID: PrototypeList::ID::HTMLSourceElement as u16,
420 },
421 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
422 _bitfield_align_1: [],
423 _bitfield_1: __BindgenBitfieldUnit::new(
424 new_jsjitinfo_bitfield_1!(
425 JSJitInfo_OpType::Setter as u8,
426 JSJitInfo_AliasSet::AliasEverything as u8,
427 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
428 false,
429 false,
430 false,
431 false,
432 false,
433 false,
434 0,
435 ).to_ne_bytes()
436 ),
437});
438}
439unsafe extern "C" fn get_media<D: DomTypes>
440(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
441 let mut result = false;
442 wrap_panic(&mut || result = (|| {
443 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
444 let this = &*(this as *const D::HTMLSourceElement);
445 <D as DomHelpers<D>>::push_new_element_queue();
446
447 let result: DOMString = this.Media();
448 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
449
450
451 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
452 return true;
453 })());
454 result
455}
456
457unsafe extern "C" fn set_media<D: DomTypes>
458(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
459 let mut result = false;
460 wrap_panic(&mut || result = (|| {
461 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
462 let this = &*(this as *const D::HTMLSourceElement);
463 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
464 Ok(ConversionResult::Success(value)) => value,
465 Ok(ConversionResult::Failure(error)) => {
466 throw_type_error(cx.raw_cx(), &error);
467 return false;
468
469 }
470 _ => {
471 return false;
472
473 },
474 }
475 ;
476 <D as DomHelpers<D>>::push_new_element_queue();
477
478 let result: () = this.SetMedia(arg0);
479 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
480
481
482 true
483 })());
484 result
485}
486
487
488static media_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
489
490pub(crate) fn init_media_getterinfo<D: DomTypes>() {
491 media_getterinfo.set(JSJitInfo {
492 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
493 getter: Some(get_media::<D>)
494 },
495 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
496 protoID: PrototypeList::ID::HTMLSourceElement as u16,
497 },
498 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
499 _bitfield_align_1: [],
500 _bitfield_1: __BindgenBitfieldUnit::new(
501 new_jsjitinfo_bitfield_1!(
502 JSJitInfo_OpType::Getter as u8,
503 JSJitInfo_AliasSet::AliasEverything as u8,
504 JSValueType::JSVAL_TYPE_STRING as u8,
505 true,
506 false,
507 false,
508 false,
509 false,
510 false,
511 0,
512 ).to_ne_bytes()
513 ),
514});
515}
516static media_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
517
518pub(crate) fn init_media_setterinfo<D: DomTypes>() {
519 media_setterinfo.set(JSJitInfo {
520 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
521 setter: Some(set_media::<D>)
522 },
523 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
524 protoID: PrototypeList::ID::HTMLSourceElement as u16,
525 },
526 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
527 _bitfield_align_1: [],
528 _bitfield_1: __BindgenBitfieldUnit::new(
529 new_jsjitinfo_bitfield_1!(
530 JSJitInfo_OpType::Setter as u8,
531 JSJitInfo_AliasSet::AliasEverything as u8,
532 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
533 false,
534 false,
535 false,
536 false,
537 false,
538 false,
539 0,
540 ).to_ne_bytes()
541 ),
542});
543}
544unsafe extern "C" fn get_width<D: DomTypes>
545(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
546 let mut result = false;
547 wrap_panic(&mut || result = (|| {
548 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
549 let this = &*(this as *const D::HTMLSourceElement);
550 <D as DomHelpers<D>>::push_new_element_queue();
551
552 let result: u32 = this.Width();
553 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
554
555
556 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
557 return true;
558 })());
559 result
560}
561
562unsafe extern "C" fn set_width<D: DomTypes>
563(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
564 let mut result = false;
565 wrap_panic(&mut || result = (|| {
566 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
567 let this = &*(this as *const D::HTMLSourceElement);
568 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
569 Ok(ConversionResult::Success(value)) => value,
570 Ok(ConversionResult::Failure(error)) => {
571 throw_type_error(cx.raw_cx(), &error);
572 return false;
573
574 }
575 _ => {
576 return false;
577
578 },
579 }
580 ;
581 <D as DomHelpers<D>>::push_new_element_queue();
582
583 let result: () = this.SetWidth(arg0);
584 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
585
586
587 true
588 })());
589 result
590}
591
592
593static width_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
594
595pub(crate) fn init_width_getterinfo<D: DomTypes>() {
596 width_getterinfo.set(JSJitInfo {
597 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
598 getter: Some(get_width::<D>)
599 },
600 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
601 protoID: PrototypeList::ID::HTMLSourceElement as u16,
602 },
603 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
604 _bitfield_align_1: [],
605 _bitfield_1: __BindgenBitfieldUnit::new(
606 new_jsjitinfo_bitfield_1!(
607 JSJitInfo_OpType::Getter as u8,
608 JSJitInfo_AliasSet::AliasEverything as u8,
609 JSValueType::JSVAL_TYPE_DOUBLE as u8,
610 true,
611 false,
612 false,
613 false,
614 false,
615 false,
616 0,
617 ).to_ne_bytes()
618 ),
619});
620}
621static width_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
622
623pub(crate) fn init_width_setterinfo<D: DomTypes>() {
624 width_setterinfo.set(JSJitInfo {
625 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
626 setter: Some(set_width::<D>)
627 },
628 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
629 protoID: PrototypeList::ID::HTMLSourceElement as u16,
630 },
631 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
632 _bitfield_align_1: [],
633 _bitfield_1: __BindgenBitfieldUnit::new(
634 new_jsjitinfo_bitfield_1!(
635 JSJitInfo_OpType::Setter as u8,
636 JSJitInfo_AliasSet::AliasEverything as u8,
637 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
638 false,
639 false,
640 false,
641 false,
642 false,
643 false,
644 0,
645 ).to_ne_bytes()
646 ),
647});
648}
649unsafe extern "C" fn get_height<D: DomTypes>
650(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
651 let mut result = false;
652 wrap_panic(&mut || result = (|| {
653 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
654 let this = &*(this as *const D::HTMLSourceElement);
655 <D as DomHelpers<D>>::push_new_element_queue();
656
657 let result: u32 = this.Height();
658 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
659
660
661 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
662 return true;
663 })());
664 result
665}
666
667unsafe extern "C" fn set_height<D: DomTypes>
668(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
669 let mut result = false;
670 wrap_panic(&mut || result = (|| {
671 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
672 let this = &*(this as *const D::HTMLSourceElement);
673 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
674 Ok(ConversionResult::Success(value)) => value,
675 Ok(ConversionResult::Failure(error)) => {
676 throw_type_error(cx.raw_cx(), &error);
677 return false;
678
679 }
680 _ => {
681 return false;
682
683 },
684 }
685 ;
686 <D as DomHelpers<D>>::push_new_element_queue();
687
688 let result: () = this.SetHeight(arg0);
689 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
690
691
692 true
693 })());
694 result
695}
696
697
698static height_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
699
700pub(crate) fn init_height_getterinfo<D: DomTypes>() {
701 height_getterinfo.set(JSJitInfo {
702 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
703 getter: Some(get_height::<D>)
704 },
705 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
706 protoID: PrototypeList::ID::HTMLSourceElement as u16,
707 },
708 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
709 _bitfield_align_1: [],
710 _bitfield_1: __BindgenBitfieldUnit::new(
711 new_jsjitinfo_bitfield_1!(
712 JSJitInfo_OpType::Getter as u8,
713 JSJitInfo_AliasSet::AliasEverything as u8,
714 JSValueType::JSVAL_TYPE_DOUBLE as u8,
715 true,
716 false,
717 false,
718 false,
719 false,
720 false,
721 0,
722 ).to_ne_bytes()
723 ),
724});
725}
726static height_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
727
728pub(crate) fn init_height_setterinfo<D: DomTypes>() {
729 height_setterinfo.set(JSJitInfo {
730 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
731 setter: Some(set_height::<D>)
732 },
733 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
734 protoID: PrototypeList::ID::HTMLSourceElement as u16,
735 },
736 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
737 _bitfield_align_1: [],
738 _bitfield_1: __BindgenBitfieldUnit::new(
739 new_jsjitinfo_bitfield_1!(
740 JSJitInfo_OpType::Setter as u8,
741 JSJitInfo_AliasSet::AliasEverything as u8,
742 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
743 false,
744 false,
745 false,
746 false,
747 false,
748 false,
749 0,
750 ).to_ne_bytes()
751 ),
752});
753}
754unsafe extern "C" fn _finalize<D: DomTypes>
755(_cx: *mut GCContext, obj: *mut JSObject){
756 wrap_panic(&mut || {
757
758 let this = native_from_object_static::<D::HTMLSourceElement>(obj).unwrap();
759 finalize_common(this);
760 })
761}
762
763unsafe extern "C" fn _trace<D: DomTypes>
764(trc: *mut JSTracer, obj: *mut JSObject){
765 wrap_panic(&mut || {
766
767 let this = native_from_object_static::<D::HTMLSourceElement>(obj).unwrap();
768 if this.is_null() { return; } (*this).trace(trc);
770 })
771}
772
773
774static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();
775
776pub(crate) fn init_class_ops<D: DomTypes>() {
777 CLASS_OPS.set(JSClassOps {
778 addProperty: None,
779 delProperty: None,
780 enumerate: None,
781 newEnumerate: None,
782 resolve: None,
783 mayResolve: None,
784 finalize: Some(_finalize::<D>),
785 call: None,
786 construct: None,
787 trace: Some(_trace::<D>),
788 });
789}
790
791pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();
792
793pub(crate) fn init_domjs_class<D: DomTypes>() {
794 init_class_ops::<D>();
795 Class.set(DOMJSClass {
796 base: JSClass {
797 name: c"HTMLSourceElement".as_ptr(),
798 flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
799 (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
800 ,
801 cOps: unsafe { CLASS_OPS.get() },
802 spec: ptr::null(),
803 ext: ptr::null(),
804 oOps: ptr::null(),
805 },
806 dom_class:
807DOMClass {
808 interface_chain: [ PrototypeList::ID::EventTarget, PrototypeList::ID::Node, PrototypeList::ID::Element, PrototypeList::ID::HTMLElement, PrototypeList::ID::HTMLSourceElement, PrototypeList::ID::Last ],
809 depth: 4,
810 type_id: crate::codegen::InheritTypes::TopTypeId { eventtarget: (crate::codegen::InheritTypes::EventTargetTypeId::Node(crate::codegen::InheritTypes::NodeTypeId::Element(crate::codegen::InheritTypes::ElementTypeId::HTMLElement(crate::codegen::InheritTypes::HTMLElementTypeId::HTMLSourceElement)))) },
811 malloc_size_of: malloc_size_of_including_raw_self::<D::HTMLSourceElement> as unsafe fn(&mut _, _) -> _,
812 global: Globals::EMPTY,
813},
814 });
815}
816
817#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
818(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::HTMLSourceElement>, _can_gc: CanGc) -> DomRoot<D::HTMLSourceElement>{
819
820 let raw = Root::new(MaybeUnreflectedDom::from_box(object));
821
822 let scope = scope.reflector().get_jsobject();
823 assert!(!scope.get().is_null());
824 assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
825 let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());
826
827 rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
828 GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
829 assert!(!canonical_proto.is_null());
830
831
832 rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
833 if let Some(given) = given_proto {
834 proto.set(*given);
835 if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
836 assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
837 }
838 } else {
839 proto.set(*canonical_proto);
840 }
841 rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
842 cx.raw_cx(),
843 &Class.get().base,
844 proto.handle(),
845 ));
846 assert!(!obj.is_null());
847 JS_SetReservedSlot(
848 obj.get(),
849 DOM_OBJECT_SLOT,
850 &PrivateValue(raw.as_ptr() as *const libc::c_void),
851 );
852
853 let root = raw.reflect_with(obj.get());
854
855
856
857 DomRoot::from_ref(&*root)
858}
859
860pub trait HTMLSourceElementMethods<D: DomTypes> {
861 fn Src(&self, ) -> USVString;
862 fn SetSrc(&self, r#value: USVString);
863 fn Type(&self, ) -> DOMString;
864 fn SetType(&self, r#value: DOMString);
865 fn Srcset(&self, ) -> USVString;
866 fn SetSrcset(&self, r#value: USVString);
867 fn Sizes(&self, ) -> DOMString;
868 fn SetSizes(&self, r#value: DOMString);
869 fn Media(&self, ) -> DOMString;
870 fn SetMedia(&self, r#value: DOMString);
871 fn Width(&self, ) -> u32;
872 fn SetWidth(&self, r#value: u32);
873 fn Height(&self, ) -> u32;
874 fn SetHeight(&self, r#value: u32);
875}
876static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
877
878pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
879 sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
880 JSPropertySpec {
881 name: JSPropertySpec_Name { string_: c"src".as_ptr() },
882 attributes_: (JSPROP_ENUMERATE),
883 kind_: (JSPropertySpec_Kind::NativeAccessor),
884 u: JSPropertySpec_AccessorsOrValue {
885 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
886 getter: JSPropertySpec_Accessor {
887 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { src_getterinfo.get() } },
888 },
889 setter: JSPropertySpec_Accessor {
890 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { src_setterinfo.get() } },
891 }
892 }
893 }
894 }
895,
896 JSPropertySpec {
897 name: JSPropertySpec_Name { string_: c"type".as_ptr() },
898 attributes_: (JSPROP_ENUMERATE),
899 kind_: (JSPropertySpec_Kind::NativeAccessor),
900 u: JSPropertySpec_AccessorsOrValue {
901 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
902 getter: JSPropertySpec_Accessor {
903 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { type_getterinfo.get() } },
904 },
905 setter: JSPropertySpec_Accessor {
906 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { type_setterinfo.get() } },
907 }
908 }
909 }
910 }
911,
912 JSPropertySpec {
913 name: JSPropertySpec_Name { string_: c"srcset".as_ptr() },
914 attributes_: (JSPROP_ENUMERATE),
915 kind_: (JSPropertySpec_Kind::NativeAccessor),
916 u: JSPropertySpec_AccessorsOrValue {
917 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
918 getter: JSPropertySpec_Accessor {
919 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { srcset_getterinfo.get() } },
920 },
921 setter: JSPropertySpec_Accessor {
922 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { srcset_setterinfo.get() } },
923 }
924 }
925 }
926 }
927,
928 JSPropertySpec {
929 name: JSPropertySpec_Name { string_: c"sizes".as_ptr() },
930 attributes_: (JSPROP_ENUMERATE),
931 kind_: (JSPropertySpec_Kind::NativeAccessor),
932 u: JSPropertySpec_AccessorsOrValue {
933 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
934 getter: JSPropertySpec_Accessor {
935 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { sizes_getterinfo.get() } },
936 },
937 setter: JSPropertySpec_Accessor {
938 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { sizes_setterinfo.get() } },
939 }
940 }
941 }
942 }
943,
944 JSPropertySpec {
945 name: JSPropertySpec_Name { string_: c"media".as_ptr() },
946 attributes_: (JSPROP_ENUMERATE),
947 kind_: (JSPropertySpec_Kind::NativeAccessor),
948 u: JSPropertySpec_AccessorsOrValue {
949 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
950 getter: JSPropertySpec_Accessor {
951 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { media_getterinfo.get() } },
952 },
953 setter: JSPropertySpec_Accessor {
954 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { media_setterinfo.get() } },
955 }
956 }
957 }
958 }
959,
960 JSPropertySpec {
961 name: JSPropertySpec_Name { string_: c"width".as_ptr() },
962 attributes_: (JSPROP_ENUMERATE),
963 kind_: (JSPropertySpec_Kind::NativeAccessor),
964 u: JSPropertySpec_AccessorsOrValue {
965 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
966 getter: JSPropertySpec_Accessor {
967 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { width_getterinfo.get() } },
968 },
969 setter: JSPropertySpec_Accessor {
970 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { width_setterinfo.get() } },
971 }
972 }
973 }
974 }
975,
976 JSPropertySpec {
977 name: JSPropertySpec_Name { string_: c"height".as_ptr() },
978 attributes_: (JSPROP_ENUMERATE),
979 kind_: (JSPropertySpec_Kind::NativeAccessor),
980 u: JSPropertySpec_AccessorsOrValue {
981 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
982 getter: JSPropertySpec_Accessor {
983 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { height_getterinfo.get() } },
984 },
985 setter: JSPropertySpec_Accessor {
986 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { height_setterinfo.get() } },
987 }
988 }
989 }
990 }
991,
992 JSPropertySpec::ZERO]))[..]
993,
994&Box::leak(Box::new([
995 JSPropertySpec {
996 name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
997 attributes_: (JSPROP_READONLY),
998 kind_: (JSPropertySpec_Kind::Value),
999 u: JSPropertySpec_AccessorsOrValue {
1000 value: JSPropertySpec_ValueWrapper {
1001 type_: JSPropertySpec_ValueWrapper_Type::String,
1002 __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
1003 string: c"HTMLSourceElement".as_ptr(),
1004 }
1005 }
1006 }
1007 }
1008,
1009 JSPropertySpec::ZERO]))[..]
1010])));
1011}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
1012
1013pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
1014 sAttributes.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[0]),
1015 Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
1016}
1017pub fn GetProtoObject<D: DomTypes>
1018(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
1019 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::HTMLSourceElement), CreateInterfaceObjects::<D>, rval)
1021}
1022
1023
1024static PrototypeClass: JSClass = JSClass {
1025 name: c"HTMLSourceElementPrototype".as_ptr(),
1026 flags:
1027 (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
1029 cOps: ptr::null(),
1030 spec: ptr::null(),
1031 ext: ptr::null(),
1032 oOps: ptr::null(),
1033};
1034
1035unsafe extern "C" fn _constructor<D: DomTypes>
1036(cx: *mut RawJSContext, argc: u32, vp: *mut JSVal) -> bool{
1037 let mut result = false;
1038 wrap_panic(&mut || result = {
1039 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1040 let args = CallArgs::from_vp(vp, argc);
1041 let global = D::GlobalScope::from_object(JS_CALLEE(cx.raw_cx(), vp).to_object());
1042
1043 <D as DomHelpers<D>>::call_html_constructor::<D::HTMLSourceElement>(
1044 SafeJSContext::from_ptr(cx.raw_cx()),
1045 &args,
1046 &global,
1047 PrototypeList::ID::HTMLSourceElement,
1048 CreateInterfaceObjects::<D>,
1049 CanGc::note()
1050 )
1051
1052 });
1053 result
1054}
1055
1056
1057static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();
1058
1059pub(crate) fn init_interface_object<D: DomTypes>() {
1060 INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
1061 Box::leak(Box::new(InterfaceConstructorBehavior::call(_constructor::<D>))),
1062 b"function HTMLSourceElement() {\n [native code]\n}",
1063 PrototypeList::ID::HTMLSourceElement,
1064 4,
1065 ));
1066}
1067
1068pub fn GetConstructorObject<D: DomTypes>
1069(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
1070 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::HTMLSourceElement), CreateInterfaceObjects::<D>, rval)
1072}
1073
1074pub fn DefineDOMInterface<D: DomTypes>
1075(cx: SafeJSContext, global: HandleObject){
1076 define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::HTMLSourceElement),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
1077}
1078
1079pub fn ConstructorEnabled<D: DomTypes>
1080(aCx: SafeJSContext, aObj: HandleObject) -> bool{
1081 is_exposed_in(aObj, Globals::WINDOW)
1082}
1083
1084unsafe fn CreateInterfaceObjects<D: DomTypes>
1085(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){
1086
1087 rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
1088 HTMLElement_Binding::GetProtoObject::<D>(cx, global, prototype_proto.handle_mut());
1089 assert!(!prototype_proto.is_null());
1090
1091 rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
1092 create_interface_prototype_object::<D>(cx,
1093 global,
1094 prototype_proto.handle(),
1095 &PrototypeClass,
1096 &[],
1097 sAttributes.get(),
1098 &[],
1099 &[],
1100 prototype.handle_mut());
1101 assert!(!prototype.is_null());
1102 assert!((*cache)[PrototypeList::ID::HTMLSourceElement as usize].is_null());
1103 (*cache)[PrototypeList::ID::HTMLSourceElement as usize] = prototype.get();
1104 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::HTMLSourceElement as isize),
1105 ptr::null_mut(),
1106 prototype.get());
1107
1108 rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
1109
1110 HTMLElement_Binding::GetConstructorObject::<D>(cx, global, interface_proto.handle_mut());
1111
1112 assert!(!interface_proto.is_null());
1113
1114 rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
1115 create_noncallback_interface_object::<D>(cx,
1116 global,
1117 interface_proto.handle(),
1118 INTERFACE_OBJECT_CLASS.get(),
1119 &[],
1120 &[],
1121 &[],
1122 prototype.handle(),
1123 c"HTMLSourceElement",
1124 0,
1125 &[],
1126 interface.handle_mut());
1127 assert!(!interface.is_null());
1128
1129 assert!((*cache)[PrototypeList::Constructor::HTMLSourceElement as usize].is_null());
1130 (*cache)[PrototypeList::Constructor::HTMLSourceElement as usize] = interface.get();
1131 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::HTMLSourceElement as isize),
1132 ptr::null_mut(),
1133 interface.get());
1134
1135}
1136
1137
1138 pub(crate) fn init_statics<D: DomTypes>() {
1139 init_interface_object::<D>();
1140 init_domjs_class::<D>();
1141
1142 init_src_getterinfo::<D>();
1143init_type_getterinfo::<D>();
1144init_srcset_getterinfo::<D>();
1145init_sizes_getterinfo::<D>();
1146init_media_getterinfo::<D>();
1147init_width_getterinfo::<D>();
1148init_height_getterinfo::<D>();
1149 init_src_setterinfo::<D>();
1150init_type_setterinfo::<D>();
1151init_srcset_setterinfo::<D>();
1152init_sizes_setterinfo::<D>();
1153init_media_setterinfo::<D>();
1154init_width_setterinfo::<D>();
1155init_height_setterinfo::<D>();
1156
1157 init_sAttributes_specs::<D>();
1158init_sAttributes_prefs::<D>();
1159 }
1160 }