#![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;
pub type EventHandler = Option<Rc<crate::dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull>>;
pub type OnErrorEventHandler = Option<Rc<crate::dom::bindings::codegen::Bindings::EventHandlerBinding::OnErrorEventHandlerNonNull>>;
pub type OnBeforeUnloadEventHandler = Option<Rc<crate::dom::bindings::codegen::Bindings::EventHandlerBinding::OnBeforeUnloadEventHandlerNonNull>>;
#[derive(JSTraceable, PartialEq)]
#[crown::unrooted_must_root_lint::allow_unrooted_interior]
pub struct EventHandlerNonNull {
pub parent: CallbackFunction,
}
impl EventHandlerNonNull {
pub unsafe fn new(aCx: SafeJSContext, aCallback: *mut JSObject) -> Rc<EventHandlerNonNull> {
let mut ret = Rc::new(EventHandlerNonNull {
parent: CallbackFunction::new()
});
match Rc::get_mut(&mut ret) {
Some(ref mut callback) => callback.parent.init(aCx, aCallback),
None => unreachable!(),
};
ret
}
pub fn Call_<T: DomObject>(&self, thisObj: &T, event: &Event, aExceptionHandling: ExceptionHandling) -> Fallible<JSVal> {
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.Call(s.get_context(), thisObjJS.handle(), event) }
}
pub fn Call__(&self, event: &Event, aExceptionHandling: ExceptionHandling) -> Fallible<JSVal> {
let s = CallSetup::new(self, aExceptionHandling);
rooted!(in(*s.get_context()) let thisObjJS = ptr::null_mut::<JSObject>());
unsafe { self.Call(s.get_context(), thisObjJS.handle(), event) }
}
unsafe fn Call(&self, cx: SafeJSContext, aThisObj: HandleObject, event: &Event) -> Fallible<JSVal> {
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());
}
rooted!(in(*cx) let callable = ObjectValue(self.callback()));
rooted!(in(*cx) let rootedThis = aThisObj.get());
let ok = !IsCallable(self.callback()) || 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);
}
let rvalDecl: HandleValue = rval.handle();
Ok(rvalDecl.get())
}
}
impl CallbackContainer for EventHandlerNonNull {
unsafe fn new(cx: SafeJSContext, callback: *mut JSObject) -> Rc<EventHandlerNonNull> {
EventHandlerNonNull::new(cx, callback)
}
fn callback_holder(&self) -> &CallbackObject {
self.parent.callback_holder()
}
}
impl ToJSValConvertible for EventHandlerNonNull {
unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
self.callback().to_jsval(cx, rval);
}
}
#[derive(JSTraceable, PartialEq)]
#[crown::unrooted_must_root_lint::allow_unrooted_interior]
pub struct OnErrorEventHandlerNonNull {
pub parent: CallbackFunction,
}
impl OnErrorEventHandlerNonNull {
pub unsafe fn new(aCx: SafeJSContext, aCallback: *mut JSObject) -> Rc<OnErrorEventHandlerNonNull> {
let mut ret = Rc::new(OnErrorEventHandlerNonNull {
parent: CallbackFunction::new()
});
match Rc::get_mut(&mut ret) {
Some(ref mut callback) => callback.parent.init(aCx, aCallback),
None => unreachable!(),
};
ret
}
pub fn Call_<T: DomObject>(&self, thisObj: &T, event: UnionTypes::EventOrString, source: Option<DOMString>, lineno: Option<u32>, column: Option<u32>, error: Option<HandleValue>, aExceptionHandling: ExceptionHandling) -> Fallible<JSVal> {
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.Call(s.get_context(), thisObjJS.handle(), event, source, lineno, column, error) }
}
pub fn Call__(&self, event: UnionTypes::EventOrString, source: Option<DOMString>, lineno: Option<u32>, column: Option<u32>, error: Option<HandleValue>, aExceptionHandling: ExceptionHandling) -> Fallible<JSVal> {
let s = CallSetup::new(self, aExceptionHandling);
rooted!(in(*s.get_context()) let thisObjJS = ptr::null_mut::<JSObject>());
unsafe { self.Call(s.get_context(), thisObjJS.handle(), event, source, lineno, column, error) }
}
unsafe fn Call(&self, cx: SafeJSContext, aThisObj: HandleObject, event: UnionTypes::EventOrString, source: Option<DOMString>, lineno: Option<u32>, column: Option<u32>, error: Option<HandleValue>) -> Fallible<JSVal> {
rooted!(in(*cx) let mut rval = UndefinedValue());
rooted_vec!(let mut argv);
argv.extend((0..5).map(|_| Heap::default()));
let mut argc = 5;
if error.is_some() {
rooted!(in(*cx) let mut argv_root = UndefinedValue());
(error.unwrap()).to_jsval(*cx, argv_root.handle_mut());
{
let arg = &mut argv[4];
*arg = Heap::default();
arg.set(argv_root.get());
}
} else if argc == 5 {
argc -= 1;
} else {
argv[4] = Heap::default();
}
if column.is_some() {
rooted!(in(*cx) let mut argv_root = UndefinedValue());
(column.unwrap()).to_jsval(*cx, argv_root.handle_mut());
{
let arg = &mut argv[3];
*arg = Heap::default();
arg.set(argv_root.get());
}
} else if argc == 4 {
argc -= 1;
} else {
argv[3] = Heap::default();
}
if lineno.is_some() {
rooted!(in(*cx) let mut argv_root = UndefinedValue());
(lineno.unwrap()).to_jsval(*cx, argv_root.handle_mut());
{
let arg = &mut argv[2];
*arg = Heap::default();
arg.set(argv_root.get());
}
} else if argc == 3 {
argc -= 1;
} else {
argv[2] = Heap::default();
}
if source.is_some() {
rooted!(in(*cx) let mut argv_root = UndefinedValue());
(source.unwrap()).to_jsval(*cx, argv_root.handle_mut());
{
let arg = &mut argv[1];
*arg = Heap::default();
arg.set(argv_root.get());
}
} else if argc == 2 {
argc -= 1;
} else {
argv[1] = Heap::default();
}
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());
}
rooted!(in(*cx) let callable = ObjectValue(self.callback()));
rooted!(in(*cx) let rootedThis = aThisObj.get());
let ok = !IsCallable(self.callback()) || 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);
}
let rvalDecl: HandleValue = rval.handle();
Ok(rvalDecl.get())
}
}
impl CallbackContainer for OnErrorEventHandlerNonNull {
unsafe fn new(cx: SafeJSContext, callback: *mut JSObject) -> Rc<OnErrorEventHandlerNonNull> {
OnErrorEventHandlerNonNull::new(cx, callback)
}
fn callback_holder(&self) -> &CallbackObject {
self.parent.callback_holder()
}
}
impl ToJSValConvertible for OnErrorEventHandlerNonNull {
unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
self.callback().to_jsval(cx, rval);
}
}
#[derive(JSTraceable, PartialEq)]
#[crown::unrooted_must_root_lint::allow_unrooted_interior]
pub struct OnBeforeUnloadEventHandlerNonNull {
pub parent: CallbackFunction,
}
impl OnBeforeUnloadEventHandlerNonNull {
pub unsafe fn new(aCx: SafeJSContext, aCallback: *mut JSObject) -> Rc<OnBeforeUnloadEventHandlerNonNull> {
let mut ret = Rc::new(OnBeforeUnloadEventHandlerNonNull {
parent: CallbackFunction::new()
});
match Rc::get_mut(&mut ret) {
Some(ref mut callback) => callback.parent.init(aCx, aCallback),
None => unreachable!(),
};
ret
}
pub fn Call_<T: DomObject>(&self, thisObj: &T, event: &Event, aExceptionHandling: ExceptionHandling) -> Fallible<Option<DOMString>> {
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.Call(s.get_context(), thisObjJS.handle(), event) }
}
pub fn Call__(&self, event: &Event, aExceptionHandling: ExceptionHandling) -> Fallible<Option<DOMString>> {
let s = CallSetup::new(self, aExceptionHandling);
rooted!(in(*s.get_context()) let thisObjJS = ptr::null_mut::<JSObject>());
unsafe { self.Call(s.get_context(), thisObjJS.handle(), event) }
}
unsafe fn Call(&self, cx: SafeJSContext, aThisObj: HandleObject, event: &Event) -> Fallible<Option<DOMString>> {
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());
}
rooted!(in(*cx) let callable = ObjectValue(self.callback()));
rooted!(in(*cx) let rootedThis = aThisObj.get());
let ok = !IsCallable(self.callback()) || 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);
}
let rvalDecl: Option<DOMString> = match FromJSValConvertible::from_jsval(*cx, rval.handle(), StringificationBehavior::Default) {
Ok(ConversionResult::Success(strval)) => strval,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(JSFailed);
}
_ => { return Err(JSFailed); },
};
Ok(rvalDecl)
}
}
impl CallbackContainer for OnBeforeUnloadEventHandlerNonNull {
unsafe fn new(cx: SafeJSContext, callback: *mut JSObject) -> Rc<OnBeforeUnloadEventHandlerNonNull> {
OnBeforeUnloadEventHandlerNonNull::new(cx, callback)
}
fn callback_holder(&self) -> &CallbackObject {
self.parent.callback_holder()
}
}
impl ToJSValConvertible for OnBeforeUnloadEventHandlerNonNull {
unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
self.callback().to_jsval(cx, rval);
}
}