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

/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */

#![allow(non_camel_case_types,non_upper_case_globals,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]

use crate::dom::bindings::import::base::*;
use crate::dom::types::Event;

#[derive(JSTraceable, PartialEq)]
#[crown::unrooted_must_root_lint::allow_unrooted_interior]
pub struct EventListener {
    pub parent: CallbackInterface,
}

impl EventListener {
    pub unsafe fn new(aCx: SafeJSContext, aCallback: *mut JSObject) -> Rc<EventListener> {
        let mut ret = Rc::new(EventListener {
            parent: CallbackInterface::new()
        });
        // Note: callback cannot be moved after calling init.
        match Rc::get_mut(&mut ret) {
            Some(ref mut callback) => callback.parent.init(aCx, aCallback),
            None => unreachable!(),
        };
        ret
    }

    pub fn HandleEvent_<T: DomObject>(&self, thisObj: &T, event: &Event, aExceptionHandling: ExceptionHandling) -> Fallible<()> {
        let s = CallSetup::new(self, aExceptionHandling);
        rooted!(in(*s.get_context()) let mut thisObjJS = ptr::null_mut::<JSObject>());
        wrap_call_this_object(s.get_context(), thisObj, thisObjJS.handle_mut());
        if thisObjJS.is_null() {
            return Err(JSFailed);
        }
        unsafe { self.HandleEvent(s.get_context(), thisObjJS.handle(), event) }
    }

    pub fn HandleEvent__(&self, event: &Event, aExceptionHandling: ExceptionHandling) -> Fallible<()> {
        let s = CallSetup::new(self, aExceptionHandling);
        rooted!(in(*s.get_context()) let thisObjJS = ptr::null_mut::<JSObject>());
        unsafe { self.HandleEvent(s.get_context(), thisObjJS.handle(), event) }
    }

    unsafe fn HandleEvent(&self, cx: SafeJSContext, aThisObj: HandleObject, event: &Event) -> Fallible<()> {
        rooted!(in(*cx) let mut rval = UndefinedValue());
        rooted_vec!(let mut argv);
        argv.extend((0..1).map(|_| Heap::default()));

        let argc = 1;

        rooted!(in(*cx) let mut argv_root = UndefinedValue());
        (event).to_jsval(*cx, argv_root.handle_mut());
        {
        let arg = &mut argv[0];
        *arg = Heap::default();
        arg.set(argv_root.get());
        }

        let isCallable = IsCallable(self.callback());
        rooted!(in(*cx) let callable =
            if isCallable {
                ObjectValue(self.callback())
            } else {
                self.parent.get_callable_property(cx, "handleEvent")?
            });
        rooted!(in(*cx) let rootedThis = if isCallable { aThisObj.get() } else { self.callback() });
        let ok = JS_CallFunctionValue(
            *cx, rootedThis.handle(), callable.handle(),
            &HandleValueArray {
                length_: argc as ::libc::size_t,
                elements_: argv.as_ptr() as *const JSVal
            }, rval.handle_mut());
        maybe_resume_unwind();
        if !ok {
            return Err(JSFailed);
        }

        Ok(())

    }
}
impl CallbackContainer for EventListener {
    unsafe fn new(cx: SafeJSContext, callback: *mut JSObject) -> Rc<EventListener> {
        EventListener::new(cx, callback)
    }

    fn callback_holder(&self) -> &CallbackObject {
        self.parent.callback_holder()
    }
}

impl ToJSValConvertible for EventListener {
    unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
        self.callback().to_jsval(cx, rval);
    }
}