#![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::codegen::Bindings::EventTargetBinding::EventTarget_Binding;
use crate::dom::bindings::import::base::*;
use crate::dom::types::EventTarget;
use crate::dom::types::Window;
#[derive(JSTraceable)]
pub struct EventModifierInit {
pub parent: crate::dom::bindings::codegen::Bindings::UIEventBinding::UIEventInit,
pub altKey: bool,
pub ctrlKey: bool,
pub keyModifierStateAltGraph: bool,
pub keyModifierStateCapsLock: bool,
pub keyModifierStateFn: bool,
pub keyModifierStateFnLock: bool,
pub keyModifierStateHyper: bool,
pub keyModifierStateNumLock: bool,
pub keyModifierStateOS: bool,
pub keyModifierStateScrollLock: bool,
pub keyModifierStateSuper: bool,
pub keyModifierStateSymbol: bool,
pub keyModifierStateSymbolLock: bool,
pub metaKey: bool,
pub shiftKey: bool,
}
impl EventModifierInit {
pub fn empty() -> Self {
Self {
parent: crate::dom::bindings::codegen::Bindings::UIEventBinding::UIEventInit::empty(),
altKey: false,
ctrlKey: false,
keyModifierStateAltGraph: false,
keyModifierStateCapsLock: false,
keyModifierStateFn: false,
keyModifierStateFnLock: false,
keyModifierStateHyper: false,
keyModifierStateNumLock: false,
keyModifierStateOS: false,
keyModifierStateScrollLock: false,
keyModifierStateSuper: false,
keyModifierStateSymbol: false,
keyModifierStateSymbolLock: false,
metaKey: false,
shiftKey: false,
}
}
pub fn new(cx: SafeJSContext, val: HandleValue)
-> Result<ConversionResult<EventModifierInit>, ()> {
unsafe {
let object = if val.get().is_null_or_undefined() {
ptr::null_mut()
} else if val.get().is_object() {
val.get().to_object()
} else {
return Ok(ConversionResult::Failure("Value is not an object.".into()));
};
rooted!(in(*cx) let object = object);
let dictionary = EventModifierInit {
parent: {
match crate::dom::bindings::codegen::Bindings::UIEventBinding::UIEventInit::new(cx, val)? {
ConversionResult::Success(v) => v,
ConversionResult::Failure(error) => {
throw_type_error(*cx, &error);
return Err(());
}
}
},
altKey: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "altKey", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
ctrlKey: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "ctrlKey", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateAltGraph: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateAltGraph", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateCapsLock: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateCapsLock", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateFn: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateFn", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateFnLock: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateFnLock", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateHyper: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateHyper", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateNumLock: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateNumLock", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateOS: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateOS", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateScrollLock: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateScrollLock", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateSuper: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateSuper", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateSymbol: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateSymbol", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
keyModifierStateSymbolLock: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "keyModifierStateSymbolLock", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
metaKey: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "metaKey", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
shiftKey: {
rooted!(in(*cx) let mut rval = UndefinedValue());
if get_dictionary_property(*cx, object.handle(), "shiftKey", rval.handle_mut())? && !rval.is_undefined() {
match FromJSValConvertible::from_jsval(*cx, rval.handle(), ()) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(());
}
_ => { return Err(());
}
}
} else {
false
}
},
};
Ok(ConversionResult::Success(dictionary))
}
}
}
impl FromJSValConvertible for EventModifierInit {
type Config = ();
unsafe fn from_jsval(cx: *mut JSContext, value: HandleValue, _option: ())
-> Result<ConversionResult<EventModifierInit>, ()> {
EventModifierInit::new(SafeJSContext::from_ptr(cx), value)
}
}
impl EventModifierInit {
pub(crate) unsafe fn to_jsobject(&self, cx: *mut JSContext, mut obj: MutableHandleObject) {
self.parent.to_jsobject(cx, obj);
let altKey = &self.altKey;
rooted!(in(cx) let mut altKey_js = UndefinedValue());
altKey.to_jsval(cx, altKey_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "altKey", altKey_js.handle()).unwrap();
let ctrlKey = &self.ctrlKey;
rooted!(in(cx) let mut ctrlKey_js = UndefinedValue());
ctrlKey.to_jsval(cx, ctrlKey_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "ctrlKey", ctrlKey_js.handle()).unwrap();
let keyModifierStateAltGraph = &self.keyModifierStateAltGraph;
rooted!(in(cx) let mut keyModifierStateAltGraph_js = UndefinedValue());
keyModifierStateAltGraph.to_jsval(cx, keyModifierStateAltGraph_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateAltGraph", keyModifierStateAltGraph_js.handle()).unwrap();
let keyModifierStateCapsLock = &self.keyModifierStateCapsLock;
rooted!(in(cx) let mut keyModifierStateCapsLock_js = UndefinedValue());
keyModifierStateCapsLock.to_jsval(cx, keyModifierStateCapsLock_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateCapsLock", keyModifierStateCapsLock_js.handle()).unwrap();
let keyModifierStateFn = &self.keyModifierStateFn;
rooted!(in(cx) let mut keyModifierStateFn_js = UndefinedValue());
keyModifierStateFn.to_jsval(cx, keyModifierStateFn_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateFn", keyModifierStateFn_js.handle()).unwrap();
let keyModifierStateFnLock = &self.keyModifierStateFnLock;
rooted!(in(cx) let mut keyModifierStateFnLock_js = UndefinedValue());
keyModifierStateFnLock.to_jsval(cx, keyModifierStateFnLock_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateFnLock", keyModifierStateFnLock_js.handle()).unwrap();
let keyModifierStateHyper = &self.keyModifierStateHyper;
rooted!(in(cx) let mut keyModifierStateHyper_js = UndefinedValue());
keyModifierStateHyper.to_jsval(cx, keyModifierStateHyper_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateHyper", keyModifierStateHyper_js.handle()).unwrap();
let keyModifierStateNumLock = &self.keyModifierStateNumLock;
rooted!(in(cx) let mut keyModifierStateNumLock_js = UndefinedValue());
keyModifierStateNumLock.to_jsval(cx, keyModifierStateNumLock_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateNumLock", keyModifierStateNumLock_js.handle()).unwrap();
let keyModifierStateOS = &self.keyModifierStateOS;
rooted!(in(cx) let mut keyModifierStateOS_js = UndefinedValue());
keyModifierStateOS.to_jsval(cx, keyModifierStateOS_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateOS", keyModifierStateOS_js.handle()).unwrap();
let keyModifierStateScrollLock = &self.keyModifierStateScrollLock;
rooted!(in(cx) let mut keyModifierStateScrollLock_js = UndefinedValue());
keyModifierStateScrollLock.to_jsval(cx, keyModifierStateScrollLock_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateScrollLock", keyModifierStateScrollLock_js.handle()).unwrap();
let keyModifierStateSuper = &self.keyModifierStateSuper;
rooted!(in(cx) let mut keyModifierStateSuper_js = UndefinedValue());
keyModifierStateSuper.to_jsval(cx, keyModifierStateSuper_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateSuper", keyModifierStateSuper_js.handle()).unwrap();
let keyModifierStateSymbol = &self.keyModifierStateSymbol;
rooted!(in(cx) let mut keyModifierStateSymbol_js = UndefinedValue());
keyModifierStateSymbol.to_jsval(cx, keyModifierStateSymbol_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateSymbol", keyModifierStateSymbol_js.handle()).unwrap();
let keyModifierStateSymbolLock = &self.keyModifierStateSymbolLock;
rooted!(in(cx) let mut keyModifierStateSymbolLock_js = UndefinedValue());
keyModifierStateSymbolLock.to_jsval(cx, keyModifierStateSymbolLock_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "keyModifierStateSymbolLock", keyModifierStateSymbolLock_js.handle()).unwrap();
let metaKey = &self.metaKey;
rooted!(in(cx) let mut metaKey_js = UndefinedValue());
metaKey.to_jsval(cx, metaKey_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "metaKey", metaKey_js.handle()).unwrap();
let shiftKey = &self.shiftKey;
rooted!(in(cx) let mut shiftKey_js = UndefinedValue());
shiftKey.to_jsval(cx, shiftKey_js.handle_mut());
set_dictionary_property(cx, obj.handle(), "shiftKey", shiftKey_js.handle()).unwrap();
}
}
impl ToJSValConvertible for EventModifierInit {
unsafe fn to_jsval(&self, cx: *mut JSContext, mut rval: MutableHandleValue) {
rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
self.to_jsobject(cx, obj.handle_mut());
rval.set(ObjectOrNullValue(obj.get()))
}
}