#![allow(non_camel_case_types,non_upper_case_globals,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)]
use crate::dom::bindings::codegen::Bindings::EventTargetBinding::EventTarget_Binding;
use crate::dom::bindings::import::base::*;
use crate::dom::types::EventTarget;
use crate::dom::types::Node;
pub use self::NodeFilter_Binding::{NodeFilterConstants, GetConstructorObject, DefineDOMInterface};
pub mod NodeFilter_Binding {
use crate::dom;
use crate::dom::bindings::codegen::Bindings::EventTargetBinding::EventTarget_Binding;
use crate::dom::bindings::import::module::*;
use crate::dom::types::EventTarget;
use crate::dom::types::Node;
pub mod NodeFilterConstants {
pub const FILTER_ACCEPT: u16 = 1;
pub const FILTER_REJECT: u16 = 2;
pub const FILTER_SKIP: u16 = 3;
pub const SHOW_ALL: u32 = 4294967295;
pub const SHOW_ELEMENT: u32 = 1;
pub const SHOW_ATTRIBUTE: u32 = 2;
pub const SHOW_TEXT: u32 = 4;
pub const SHOW_CDATA_SECTION: u32 = 8;
pub const SHOW_ENTITY_REFERENCE: u32 = 16;
pub const SHOW_ENTITY: u32 = 32;
pub const SHOW_PROCESSING_INSTRUCTION: u32 = 64;
pub const SHOW_COMMENT: u32 = 128;
pub const SHOW_DOCUMENT: u32 = 256;
pub const SHOW_DOCUMENT_TYPE: u32 = 512;
pub const SHOW_DOCUMENT_FRAGMENT: u32 = 1024;
pub const SHOW_NOTATION: u32 = 2048;
} const sConstants_specs: &[&[ConstantSpec]] = &[
&[
ConstantSpec { name: c"FILTER_ACCEPT", value: ConstantVal::Int(1) },
ConstantSpec { name: c"FILTER_REJECT", value: ConstantVal::Int(2) },
ConstantSpec { name: c"FILTER_SKIP", value: ConstantVal::Int(3) },
ConstantSpec { name: c"SHOW_ALL", value: ConstantVal::Uint(4294967295) },
ConstantSpec { name: c"SHOW_ELEMENT", value: ConstantVal::Uint(1) },
ConstantSpec { name: c"SHOW_ATTRIBUTE", value: ConstantVal::Uint(2) },
ConstantSpec { name: c"SHOW_TEXT", value: ConstantVal::Uint(4) },
ConstantSpec { name: c"SHOW_CDATA_SECTION", value: ConstantVal::Uint(8) },
ConstantSpec { name: c"SHOW_ENTITY_REFERENCE", value: ConstantVal::Uint(16) },
ConstantSpec { name: c"SHOW_ENTITY", value: ConstantVal::Uint(32) },
ConstantSpec { name: c"SHOW_PROCESSING_INSTRUCTION", value: ConstantVal::Uint(64) },
ConstantSpec { name: c"SHOW_COMMENT", value: ConstantVal::Uint(128) },
ConstantSpec { name: c"SHOW_DOCUMENT", value: ConstantVal::Uint(256) },
ConstantSpec { name: c"SHOW_DOCUMENT_TYPE", value: ConstantVal::Uint(512) },
ConstantSpec { name: c"SHOW_DOCUMENT_FRAGMENT", value: ConstantVal::Uint(1024) },
ConstantSpec { name: c"SHOW_NOTATION", value: ConstantVal::Uint(2048) }]
];
const sConstants: &[Guard<&[ConstantSpec]>] = &[
Guard::new(Condition::Exposed(InterfaceObjectMap::Globals::WINDOW), sConstants_specs[0])
];
pub fn GetConstructorObject(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::NodeFilter), CreateInterfaceObjects, rval)
}
pub fn DefineDOMInterface(cx: SafeJSContext, global: HandleObject){
define_dom_interface(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::NodeFilter), CreateInterfaceObjects, ConstructorEnabled)
}
fn ConstructorEnabled(aCx: SafeJSContext, aObj: HandleObject) -> bool{
is_exposed_in(aObj, InterfaceObjectMap::Globals::WINDOW)
}
unsafe fn CreateInterfaceObjects(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){
rooted!(in(*cx) let mut interface = ptr::null_mut::<JSObject>());
create_callback_interface_object(cx, global, sConstants, c"NodeFilter", interface.handle_mut());
assert!(!interface.is_null());
assert!((*cache)[PrototypeList::Constructor::NodeFilter as usize].is_null());
(*cache)[PrototypeList::Constructor::NodeFilter as usize] = interface.get();
<*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::NodeFilter as isize),
ptr::null_mut(),
interface.get());
}
} #[derive(JSTraceable, PartialEq)]
#[crown::unrooted_must_root_lint::allow_unrooted_interior]
pub struct NodeFilter {
pub parent: CallbackInterface,
}
impl NodeFilter {
pub unsafe fn new(aCx: SafeJSContext, aCallback: *mut JSObject) -> Rc<NodeFilter> {
let mut ret = Rc::new(NodeFilter {
parent: CallbackInterface::new()
});
match Rc::get_mut(&mut ret) {
Some(ref mut callback) => callback.parent.init(aCx, aCallback),
None => unreachable!(),
};
ret
}
pub fn AcceptNode_<T: DomObject>(&self, thisObj: &T, node: &Node, aExceptionHandling: ExceptionHandling) -> Fallible<u16> {
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.AcceptNode(s.get_context(), thisObjJS.handle(), node) }
}
pub fn AcceptNode__<>(&self, node: &Node, aExceptionHandling: ExceptionHandling) -> Fallible<u16> {
let s = CallSetup::new(self, aExceptionHandling);
rooted!(in(*s.get_context()) let thisObjJS = ptr::null_mut::<JSObject>());
unsafe { self.AcceptNode(s.get_context(), thisObjJS.handle(), node) }
}
unsafe fn AcceptNode<>(&self, cx: SafeJSContext, aThisObj: HandleObject, node: &Node) -> Fallible<u16> {
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());
(node).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, "acceptNode")?
});
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);
}
let rvalDecl: u16 = match FromJSValConvertible::from_jsval(*cx, rval.handle(), ConversionBehavior::Default) {
Ok(ConversionResult::Success(v)) => v,
Ok(ConversionResult::Failure(error)) => {
throw_type_error(*cx, &error);
return Err(JSFailed);
}
_ => { return Err(JSFailed);
}
};
Ok(rvalDecl)
}
}
impl CallbackContainer for NodeFilter {
unsafe fn new(cx: SafeJSContext, callback: *mut JSObject) -> Rc<NodeFilter> {
NodeFilter::new(cx, callback)
}
fn callback_holder(&self) -> &CallbackObject {
self.parent.callback_holder()
}
}
impl ToJSValConvertible for NodeFilter {
unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
self.callback().to_jsval(cx, rval);
}
}