/* 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::*;

pub use self::EXTBlendMinmax_Binding::{EXTBlendMinmaxConstants, Wrap, GetProtoObject};
pub mod EXTBlendMinmax_Binding {
use crate::dom;
use crate::dom::bindings::import::module::*;
use crate::dom::types::EXTBlendMinmax;

unsafe extern fn _finalize(_cx: *mut GCContext, obj: *mut JSObject) {
    wrap_panic(&mut || {

        let this = native_from_object_static::<EXTBlendMinmax>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern fn _trace(trc: *mut JSTracer, obj: *mut JSObject) {
    wrap_panic(&mut || {

        let this = native_from_object_static::<EXTBlendMinmax>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}

pub mod EXTBlendMinmaxConstants {
    pub const MIN_EXT: u32 = 32775;
    pub const MAX_EXT: u32 = 32776;
} // mod EXTBlendMinmaxConstants
static CLASS_OPS: JSClassOps = JSClassOps {
    addProperty: None,
    delProperty: None,
    enumerate: None,
    newEnumerate: None,
    resolve: None,
    mayResolve: None,
    finalize: Some(_finalize),
    call: None,
    construct: None,
    trace: Some(_trace),
};

static Class: DOMJSClass = DOMJSClass {
    base: JSClass {
        name: b"EXTBlendMinmax\0" as *const u8 as *const libc::c_char,
        flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
               (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
               /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
        cOps: &CLASS_OPS,
        spec: ptr::null(),
        ext: ptr::null(),
        oOps: ptr::null(),
    },
    dom_class: DOMClass {
    interface_chain: [ PrototypeList::ID::EXTBlendMinmax, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::dom::bindings::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<EXTBlendMinmax> as unsafe fn(&mut _, _) -> _,
    global: InterfaceObjectMap::Globals::EMPTY,
}
};

impl EXTBlendMinmax {
    fn __assert_parent_type(&self) {
        use crate::dom::bindings::inheritance::HasParent;
        // If this type assertion fails, make sure the first field of your
        // DOM struct is of the correct type -- it must be the parent class.
        let _: &Reflector = self.as_parent();
    }
}

pub unsafe fn Wrap(cx: SafeJSContext, scope: &GlobalScope, given_proto: Option<HandleObject>, object: Box<EXTBlendMinmax>) -> DomRoot<EXTBlendMinmax> {
    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(*cx, scope.get());

    rooted!(in(*cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(in(*cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        *proto = *given;
        if get_context_realm(*cx) != get_object_realm(*given) {
            assert!(JS_WrapObject(*cx, proto.handle_mut()));
        }
    } else {
        *proto = *canonical_proto;
    }
    rooted!(in(*cx) let obj = JS_NewObjectWithGivenProto(
        *cx,
        &Class.base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

impl DomObjectWrap for dom::extblendminmax::EXTBlendMinmax {
    const WRAP: unsafe fn(
        SafeJSContext,
        &GlobalScope,
        Option<HandleObject>,
        Box<Self>,
    ) -> Root<Dom<Self>> = Wrap;
}

impl IDLInterface for EXTBlendMinmax {
    #[inline]
    fn derives(class: &'static DOMClass) -> bool {
        ptr::eq(class, &Class.dom_class)
    }
}

impl PartialEq for EXTBlendMinmax {
    fn eq(&self, other: &EXTBlendMinmax) -> bool {
        self as *const EXTBlendMinmax == other
    }
}

const sAttributes_specs: &[&[JSPropertySpec]] = &[
&[
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: b"EXTBlendMinmax\0" as *const u8 as *const libc::c_char,
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]

];
const sAttributes: &[Guard<&[JSPropertySpec]>] = &[
    Guard::new(Condition::Satisfied, sAttributes_specs[0])
];
const sConstants_specs: &[&[ConstantSpec]] = &[
&[
    ConstantSpec { name: b"MIN_EXT\0", value: ConstantVal::UintVal(32775) },
    ConstantSpec { name: b"MAX_EXT\0", value: ConstantVal::UintVal(32776) }]

];
const sConstants: &[Guard<&[ConstantSpec]>] = &[
    Guard::new(Condition::Exposed(InterfaceObjectMap::Globals::WINDOW), sConstants_specs[0])
];

pub fn GetProtoObject(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject) {
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */
            get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::EXTBlendMinmax), CreateInterfaceObjects, rval)

}

static PrototypeClass: JSClass = JSClass {
    name: b"EXTBlendMinmaxPrototype\0" as *const u8 as *const libc::c_char,
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS(0)
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: 0 as *const _,
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};

unsafe fn CreateInterfaceObjects(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray) {
    rooted!(in(*cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(*cx));
    assert!(!prototype_proto.is_null());

    rooted!(in(*cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes,
                                      sConstants,
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::EXTBlendMinmax as usize].is_null());
    (*cache)[PrototypeList::ID::EXTBlendMinmax as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::EXTBlendMinmax as isize),
                                  ptr::null_mut(),
                                  prototype.get());

}
} // mod EXTBlendMinmax_Binding