1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

/* 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::SVGGraphicsElement_Binding::{GetProtoObject, GetConstructorObject, DefineDOMInterface};
pub mod SVGGraphicsElement_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::codegen::Bindings::SVGElementBinding::SVGElement_Binding;
use crate::dom::bindings::import::module::*;
use crate::dom::types::Element;
use crate::dom::types::EventTarget;
use crate::dom::types::Node;
use crate::dom::types::SVGElement;
use crate::dom::types::SVGGraphicsElement;

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

impl PartialEq for SVGGraphicsElement {
    fn eq(&self, other: &SVGGraphicsElement) -> bool {
        self as *const SVGGraphicsElement == 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"SVGGraphicsElement\0" as *const u8 as *const libc::c_char,
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]

];
const sAttributes: &[Guard<&[JSPropertySpec]>] = &[
    Guard::new(Condition::Satisfied, sAttributes_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::SVGGraphicsElement), CreateInterfaceObjects, rval)

}

static PrototypeClass: JSClass = JSClass {
    name: b"SVGGraphicsElementPrototype\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 SVGGraphicsElement() {\n    [native code]\n}",
        PrototypeList::ID::SVGGraphicsElement,
        4);

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

}

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

            define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::SVGGraphicsElement), 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>());
    SVGElement_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::SVGGraphicsElement as usize].is_null());
    (*cache)[PrototypeList::ID::SVGGraphicsElement as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::SVGGraphicsElement as isize),
                                  ptr::null_mut(),
                                  prototype.get());

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

    SVGElement_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"SVGGraphicsElement\0",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
    assert!((*cache)[PrototypeList::Constructor::SVGGraphicsElement as usize].is_null());
    (*cache)[PrototypeList::Constructor::SVGGraphicsElement as usize] = interface.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::SVGGraphicsElement as isize),
                                  ptr::null_mut(),
                                  interface.get());

}
} // mod SVGGraphicsElement_Binding