/* 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::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;
} // mod NodeFilterConstants
const sConstants_specs: &[&[ConstantSpec]] = &[
&[
    ConstantSpec { name: b"FILTER_ACCEPT\0", value: ConstantVal::IntVal(1) },
    ConstantSpec { name: b"FILTER_REJECT\0", value: ConstantVal::IntVal(2) },
    ConstantSpec { name: b"FILTER_SKIP\0", value: ConstantVal::IntVal(3) },
    ConstantSpec { name: b"SHOW_ALL\0", value: ConstantVal::UintVal(4294967295) },
    ConstantSpec { name: b"SHOW_ELEMENT\0", value: ConstantVal::UintVal(1) },
    ConstantSpec { name: b"SHOW_ATTRIBUTE\0", value: ConstantVal::UintVal(2) },
    ConstantSpec { name: b"SHOW_TEXT\0", value: ConstantVal::UintVal(4) },
    ConstantSpec { name: b"SHOW_CDATA_SECTION\0", value: ConstantVal::UintVal(8) },
    ConstantSpec { name: b"SHOW_ENTITY_REFERENCE\0", value: ConstantVal::UintVal(16) },
    ConstantSpec { name: b"SHOW_ENTITY\0", value: ConstantVal::UintVal(32) },
    ConstantSpec { name: b"SHOW_PROCESSING_INSTRUCTION\0", value: ConstantVal::UintVal(64) },
    ConstantSpec { name: b"SHOW_COMMENT\0", value: ConstantVal::UintVal(128) },
    ConstantSpec { name: b"SHOW_DOCUMENT\0", value: ConstantVal::UintVal(256) },
    ConstantSpec { name: b"SHOW_DOCUMENT_TYPE\0", value: ConstantVal::UintVal(512) },
    ConstantSpec { name: b"SHOW_DOCUMENT_FRAGMENT\0", value: ConstantVal::UintVal(1024) },
    ConstantSpec { name: b"SHOW_NOTATION\0", value: ConstantVal::UintVal(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 the interface object for this class.  This will create the object as
       needed. */
            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, b"NodeFilter\0", 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());

}
} // mod NodeFilter_Binding


#[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()
        });
        // 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 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);
    }
}