/* 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::SVGElement_Binding::{Wrap, SVGElementMethods, GetProtoObject, GetConstructorObject, DefineDOMInterface};
pub mod SVGElement_Binding {
use crate::dom;
use crate::dom::bindings::codegen::Bindings::ElementBinding::Element_Binding;
use crate::dom::bindings::codegen::Bindings::EventTargetBinding::EventTarget_Binding;
use crate::dom::bindings::codegen::Bindings::NodeBinding::Node_Binding;
use crate::dom::bindings::import::module::*;
use crate::dom::types::CSSStyleDeclaration;
use crate::dom::types::Element;
use crate::dom::types::EventTarget;
use crate::dom::types::Node;
use crate::dom::types::SVGElement;

unsafe extern fn get_style(cx: *mut JSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool {
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let cx = SafeJSContext::from_ptr(cx);
        let this = &*(this as *const SVGElement);
        let result: DomRoot<CSSStyleDeclaration> = this.Style();

        (result).to_jsval(*cx, MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern fn set_style(cx: *mut JSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool {
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let cx = SafeJSContext::from_ptr(cx);
        rooted!(in(*cx) let mut v = UndefinedValue());
        if !JS_GetProperty(*cx, HandleObject::from_raw(obj), b"style\0" as *const u8 as *const libc::c_char, v.handle_mut()) {
            return false;
        }
        if !v.is_object() {
            throw_type_error(*cx, "Value.style is not an object.");
            return false;
        }
        rooted!(in(*cx) let target_obj = v.to_object());
        JS_SetProperty(*cx, target_obj.handle(), b"cssText\0" as *const u8 as *const libc::c_char, HandleValue::from_raw(args.get(0)))

    })());
    result
}


const style_getterinfo: JSJitInfo = JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_style)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::SVGElement as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 3 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasNone as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            true,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
};

const style_setterinfo: JSJitInfo = JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_style)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::SVGElement as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 3 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
};

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

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

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

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

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"SVGElement\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::EventTarget, PrototypeList::ID::Node, PrototypeList::ID::Element, PrototypeList::ID::SVGElement, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 3,
    type_id: crate::dom::bindings::codegen::InheritTypes::TopTypeId { eventtarget: (crate::dom::bindings::codegen::InheritTypes::EventTargetTypeId::Node(crate::dom::bindings::codegen::InheritTypes::NodeTypeId::Element(crate::dom::bindings::codegen::InheritTypes::ElementTypeId::SVGElement(crate::dom::bindings::codegen::InheritTypes::SVGElementTypeId::SVGElement)))) },
    malloc_size_of: malloc_size_of_including_raw_self::<SVGElement> as unsafe fn(&mut _, _) -> _,
    global: InterfaceObjectMap::Globals::EMPTY,
}
};

impl SVGElement {
    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 _: &Element = self.as_parent();
    }
}

pub unsafe fn Wrap(cx: SafeJSContext, scope: &GlobalScope, given_proto: Option<HandleObject>, object: Box<SVGElement>) -> DomRoot<SVGElement> {
    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::svgelement::SVGElement {
    const WRAP: unsafe fn(
        SafeJSContext,
        &GlobalScope,
        Option<HandleObject>,
        Box<Self>,
    ) -> Root<Dom<Self>> = Wrap;
}

impl IDLInterface for SVGElement {
    #[inline]
    fn derives(class: &'static DOMClass) -> bool {
        class.interface_chain[3] == PrototypeList::ID::SVGElement
    }
}

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

pub trait SVGElementMethods {
    fn Style(&self) -> DomRoot<CSSStyleDeclaration>;
}
const sAttributes_specs: &[&[JSPropertySpec]] = &[
&[
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: b"style\0" as *const u8 as *const libc::c_char },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter), info: &style_getterinfo },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: &style_setterinfo },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]
,
&[
    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"SVGElement\0" as *const u8 as *const libc::c_char,
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]

];
const sAttributes: &[Guard<&[JSPropertySpec]>] = &[
    Guard::new(Condition::Exposed(InterfaceObjectMap::Globals::WINDOW), sAttributes_specs[0]),
    Guard::new(Condition::Satisfied, sAttributes_specs[1])
];

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::SVGElement), CreateInterfaceObjects, rval)

}

static PrototypeClass: JSClass = JSClass {
    name: b"SVGElementPrototype\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(),
};

static INTERFACE_OBJECT_CLASS: NonCallbackInterfaceObjectClass =
    NonCallbackInterfaceObjectClass::new(
        {
            // Intermediate `const` because as of nightly-2018-10-05,
            // rustc is conservative in promotion to `'static` of the return values of `const fn`s:
            // https://github.com/rust-lang/rust/issues/54846
            // https://github.com/rust-lang/rust/pull/53851
            const BEHAVIOR: InterfaceConstructorBehavior = InterfaceConstructorBehavior::throw();
            &BEHAVIOR
        },
        b"function SVGElement() {\n    [native code]\n}",
        PrototypeList::ID::SVGElement,
        3);

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::SVGElement), CreateInterfaceObjects, rval)

}

pub fn DefineDOMInterface(cx: SafeJSContext, global: HandleObject) {

            define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::SVGElement), CreateInterfaceObjects, ConstructorEnabled)

}

fn ConstructorEnabled(aCx: SafeJSContext, aObj: HandleObject) -> bool {
    is_exposed_in(aObj, InterfaceObjectMap::Globals::WINDOW) &&
    pref!(dom.svg.enabled)
}

unsafe fn CreateInterfaceObjects(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray) {
    rooted!(in(*cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    Element_Binding::GetProtoObject(cx, global, prototype_proto.handle_mut());
    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,
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::SVGElement as usize].is_null());
    (*cache)[PrototypeList::ID::SVGElement as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::SVGElement as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(in(*cx) let mut interface_proto = ptr::null_mut::<JSObject>());

    Element_Binding::GetConstructorObject(cx, global, interface_proto.handle_mut());
    assert!(!interface_proto.is_null());

    rooted!(in(*cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object(cx,
                                        global,
                                        interface_proto.handle(),
                                        &INTERFACE_OBJECT_CLASS,
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        b"SVGElement\0",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
    assert!((*cache)[PrototypeList::Constructor::SVGElement as usize].is_null());
    (*cache)[PrototypeList::Constructor::SVGElement as usize] = interface.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::SVGElement as isize),
                                  ptr::null_mut(),
                                  interface.get());

}
} // mod SVGElement_Binding