Line data Source code
1 : /* THIS FILE IS AUTOGENERATED FROM SVGPathSeg.webidl BY Codegen.py - DO NOT EDIT */
2 :
3 : #ifndef mozilla_dom_SVGPathSegBinding_h
4 : #define mozilla_dom_SVGPathSegBinding_h
5 :
6 : #include "js/RootingAPI.h"
7 : #include "jspubtd.h"
8 : #include "mozilla/ErrorResult.h"
9 : #include "mozilla/dom/BindingDeclarations.h"
10 : #include "mozilla/dom/Nullable.h"
11 :
12 : namespace mozilla {
13 :
14 : class DOMSVGPathSeg;
15 : class DOMSVGPathSegArcAbs;
16 : struct DOMSVGPathSegArcAbsAtoms;
17 : class DOMSVGPathSegArcRel;
18 : struct DOMSVGPathSegArcRelAtoms;
19 : struct DOMSVGPathSegAtoms;
20 : class DOMSVGPathSegClosePath;
21 : struct DOMSVGPathSegClosePathAtoms;
22 : class DOMSVGPathSegCurvetoCubicAbs;
23 : struct DOMSVGPathSegCurvetoCubicAbsAtoms;
24 : class DOMSVGPathSegCurvetoCubicRel;
25 : struct DOMSVGPathSegCurvetoCubicRelAtoms;
26 : class DOMSVGPathSegCurvetoCubicSmoothAbs;
27 : struct DOMSVGPathSegCurvetoCubicSmoothAbsAtoms;
28 : class DOMSVGPathSegCurvetoCubicSmoothRel;
29 : struct DOMSVGPathSegCurvetoCubicSmoothRelAtoms;
30 : class DOMSVGPathSegCurvetoQuadraticAbs;
31 : struct DOMSVGPathSegCurvetoQuadraticAbsAtoms;
32 : class DOMSVGPathSegCurvetoQuadraticRel;
33 : struct DOMSVGPathSegCurvetoQuadraticRelAtoms;
34 : class DOMSVGPathSegCurvetoQuadraticSmoothAbs;
35 : struct DOMSVGPathSegCurvetoQuadraticSmoothAbsAtoms;
36 : class DOMSVGPathSegCurvetoQuadraticSmoothRel;
37 : struct DOMSVGPathSegCurvetoQuadraticSmoothRelAtoms;
38 : class DOMSVGPathSegLinetoAbs;
39 : struct DOMSVGPathSegLinetoAbsAtoms;
40 : class DOMSVGPathSegLinetoHorizontalAbs;
41 : struct DOMSVGPathSegLinetoHorizontalAbsAtoms;
42 : class DOMSVGPathSegLinetoHorizontalRel;
43 : struct DOMSVGPathSegLinetoHorizontalRelAtoms;
44 : class DOMSVGPathSegLinetoRel;
45 : struct DOMSVGPathSegLinetoRelAtoms;
46 : class DOMSVGPathSegLinetoVerticalAbs;
47 : struct DOMSVGPathSegLinetoVerticalAbsAtoms;
48 : class DOMSVGPathSegLinetoVerticalRel;
49 : struct DOMSVGPathSegLinetoVerticalRelAtoms;
50 : class DOMSVGPathSegMovetoAbs;
51 : struct DOMSVGPathSegMovetoAbsAtoms;
52 : class DOMSVGPathSegMovetoRel;
53 : struct DOMSVGPathSegMovetoRelAtoms;
54 :
55 : namespace dom {
56 :
57 : struct NativePropertyHooks;
58 : class ProtoAndIfaceCache;
59 :
60 : } // namespace dom
61 :
62 : } // namespace mozilla
63 :
64 : namespace mozilla {
65 : namespace dom {
66 :
67 : namespace SVGPathSegBinding {
68 :
69 : typedef mozilla::DOMSVGPathSeg NativeType;
70 :
71 : JSObject*
72 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
73 :
74 : // We declare this as an array so that retrieving a pointer to this
75 : // binding's property hooks only requires compile/link-time resolvable
76 : // address arithmetic. Declaring it as a pointer instead would require
77 : // doing a run-time load to fetch a pointer to this binding's property
78 : // hooks. And then structures which embedded a pointer to this structure
79 : // would require a run-time load for proper initialization, which would
80 : // then induce static constructors. Lots of static constructors.
81 : extern const NativePropertyHooks sNativePropertyHooks[];
82 :
83 : void
84 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
85 :
86 : JS::Handle<JSObject*>
87 : GetProtoObjectHandle(JSContext* aCx);
88 :
89 : JSObject*
90 : GetProtoObject(JSContext* aCx);
91 :
92 : JS::Handle<JSObject*>
93 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
94 :
95 : JSObject*
96 : GetConstructorObject(JSContext* aCx);
97 :
98 : } // namespace SVGPathSegBinding
99 :
100 :
101 :
102 : namespace SVGPathSegArcAbsBinding {
103 :
104 : typedef mozilla::DOMSVGPathSegArcAbs NativeType;
105 :
106 : JSObject*
107 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
108 :
109 : const JSClass*
110 : GetJSClass();
111 :
112 : bool
113 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegArcAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
114 :
115 : template <class T>
116 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
117 : {
118 0 : JS::Rooted<JSObject*> reflector(aCx);
119 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
120 : }
121 :
122 : // We declare this as an array so that retrieving a pointer to this
123 : // binding's property hooks only requires compile/link-time resolvable
124 : // address arithmetic. Declaring it as a pointer instead would require
125 : // doing a run-time load to fetch a pointer to this binding's property
126 : // hooks. And then structures which embedded a pointer to this structure
127 : // would require a run-time load for proper initialization, which would
128 : // then induce static constructors. Lots of static constructors.
129 : extern const NativePropertyHooks sNativePropertyHooks[];
130 :
131 : void
132 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
133 :
134 : JS::Handle<JSObject*>
135 : GetProtoObjectHandle(JSContext* aCx);
136 :
137 : JS::Handle<JSObject*>
138 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
139 :
140 : JSObject*
141 : GetConstructorObject(JSContext* aCx);
142 :
143 : } // namespace SVGPathSegArcAbsBinding
144 :
145 :
146 :
147 : namespace SVGPathSegArcRelBinding {
148 :
149 : typedef mozilla::DOMSVGPathSegArcRel NativeType;
150 :
151 : JSObject*
152 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
153 :
154 : const JSClass*
155 : GetJSClass();
156 :
157 : bool
158 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegArcRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
159 :
160 : template <class T>
161 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
162 : {
163 0 : JS::Rooted<JSObject*> reflector(aCx);
164 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
165 : }
166 :
167 : // We declare this as an array so that retrieving a pointer to this
168 : // binding's property hooks only requires compile/link-time resolvable
169 : // address arithmetic. Declaring it as a pointer instead would require
170 : // doing a run-time load to fetch a pointer to this binding's property
171 : // hooks. And then structures which embedded a pointer to this structure
172 : // would require a run-time load for proper initialization, which would
173 : // then induce static constructors. Lots of static constructors.
174 : extern const NativePropertyHooks sNativePropertyHooks[];
175 :
176 : void
177 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
178 :
179 : JS::Handle<JSObject*>
180 : GetProtoObjectHandle(JSContext* aCx);
181 :
182 : JS::Handle<JSObject*>
183 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
184 :
185 : JSObject*
186 : GetConstructorObject(JSContext* aCx);
187 :
188 : } // namespace SVGPathSegArcRelBinding
189 :
190 :
191 :
192 : namespace SVGPathSegClosePathBinding {
193 :
194 : typedef mozilla::DOMSVGPathSegClosePath NativeType;
195 :
196 : JSObject*
197 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
198 :
199 : const JSClass*
200 : GetJSClass();
201 :
202 : bool
203 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegClosePath* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
204 :
205 : template <class T>
206 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
207 : {
208 0 : JS::Rooted<JSObject*> reflector(aCx);
209 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
210 : }
211 :
212 : // We declare this as an array so that retrieving a pointer to this
213 : // binding's property hooks only requires compile/link-time resolvable
214 : // address arithmetic. Declaring it as a pointer instead would require
215 : // doing a run-time load to fetch a pointer to this binding's property
216 : // hooks. And then structures which embedded a pointer to this structure
217 : // would require a run-time load for proper initialization, which would
218 : // then induce static constructors. Lots of static constructors.
219 : extern const NativePropertyHooks sNativePropertyHooks[];
220 :
221 : void
222 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
223 :
224 : JS::Handle<JSObject*>
225 : GetProtoObjectHandle(JSContext* aCx);
226 :
227 : JS::Handle<JSObject*>
228 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
229 :
230 : JSObject*
231 : GetConstructorObject(JSContext* aCx);
232 :
233 : } // namespace SVGPathSegClosePathBinding
234 :
235 :
236 :
237 : namespace SVGPathSegCurvetoCubicAbsBinding {
238 :
239 : typedef mozilla::DOMSVGPathSegCurvetoCubicAbs NativeType;
240 :
241 : JSObject*
242 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
243 :
244 : const JSClass*
245 : GetJSClass();
246 :
247 : bool
248 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoCubicAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
249 :
250 : template <class T>
251 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
252 : {
253 0 : JS::Rooted<JSObject*> reflector(aCx);
254 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
255 : }
256 :
257 : // We declare this as an array so that retrieving a pointer to this
258 : // binding's property hooks only requires compile/link-time resolvable
259 : // address arithmetic. Declaring it as a pointer instead would require
260 : // doing a run-time load to fetch a pointer to this binding's property
261 : // hooks. And then structures which embedded a pointer to this structure
262 : // would require a run-time load for proper initialization, which would
263 : // then induce static constructors. Lots of static constructors.
264 : extern const NativePropertyHooks sNativePropertyHooks[];
265 :
266 : void
267 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
268 :
269 : JS::Handle<JSObject*>
270 : GetProtoObjectHandle(JSContext* aCx);
271 :
272 : JS::Handle<JSObject*>
273 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
274 :
275 : JSObject*
276 : GetConstructorObject(JSContext* aCx);
277 :
278 : } // namespace SVGPathSegCurvetoCubicAbsBinding
279 :
280 :
281 :
282 : namespace SVGPathSegCurvetoCubicRelBinding {
283 :
284 : typedef mozilla::DOMSVGPathSegCurvetoCubicRel NativeType;
285 :
286 : JSObject*
287 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
288 :
289 : const JSClass*
290 : GetJSClass();
291 :
292 : bool
293 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoCubicRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
294 :
295 : template <class T>
296 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
297 : {
298 0 : JS::Rooted<JSObject*> reflector(aCx);
299 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
300 : }
301 :
302 : // We declare this as an array so that retrieving a pointer to this
303 : // binding's property hooks only requires compile/link-time resolvable
304 : // address arithmetic. Declaring it as a pointer instead would require
305 : // doing a run-time load to fetch a pointer to this binding's property
306 : // hooks. And then structures which embedded a pointer to this structure
307 : // would require a run-time load for proper initialization, which would
308 : // then induce static constructors. Lots of static constructors.
309 : extern const NativePropertyHooks sNativePropertyHooks[];
310 :
311 : void
312 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
313 :
314 : JS::Handle<JSObject*>
315 : GetProtoObjectHandle(JSContext* aCx);
316 :
317 : JS::Handle<JSObject*>
318 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
319 :
320 : JSObject*
321 : GetConstructorObject(JSContext* aCx);
322 :
323 : } // namespace SVGPathSegCurvetoCubicRelBinding
324 :
325 :
326 :
327 : namespace SVGPathSegCurvetoCubicSmoothAbsBinding {
328 :
329 : typedef mozilla::DOMSVGPathSegCurvetoCubicSmoothAbs NativeType;
330 :
331 : JSObject*
332 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
333 :
334 : const JSClass*
335 : GetJSClass();
336 :
337 : bool
338 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoCubicSmoothAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
339 :
340 : template <class T>
341 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
342 : {
343 0 : JS::Rooted<JSObject*> reflector(aCx);
344 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
345 : }
346 :
347 : // We declare this as an array so that retrieving a pointer to this
348 : // binding's property hooks only requires compile/link-time resolvable
349 : // address arithmetic. Declaring it as a pointer instead would require
350 : // doing a run-time load to fetch a pointer to this binding's property
351 : // hooks. And then structures which embedded a pointer to this structure
352 : // would require a run-time load for proper initialization, which would
353 : // then induce static constructors. Lots of static constructors.
354 : extern const NativePropertyHooks sNativePropertyHooks[];
355 :
356 : void
357 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
358 :
359 : JS::Handle<JSObject*>
360 : GetProtoObjectHandle(JSContext* aCx);
361 :
362 : JS::Handle<JSObject*>
363 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
364 :
365 : JSObject*
366 : GetConstructorObject(JSContext* aCx);
367 :
368 : } // namespace SVGPathSegCurvetoCubicSmoothAbsBinding
369 :
370 :
371 :
372 : namespace SVGPathSegCurvetoCubicSmoothRelBinding {
373 :
374 : typedef mozilla::DOMSVGPathSegCurvetoCubicSmoothRel NativeType;
375 :
376 : JSObject*
377 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
378 :
379 : const JSClass*
380 : GetJSClass();
381 :
382 : bool
383 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoCubicSmoothRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
384 :
385 : template <class T>
386 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
387 : {
388 0 : JS::Rooted<JSObject*> reflector(aCx);
389 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
390 : }
391 :
392 : // We declare this as an array so that retrieving a pointer to this
393 : // binding's property hooks only requires compile/link-time resolvable
394 : // address arithmetic. Declaring it as a pointer instead would require
395 : // doing a run-time load to fetch a pointer to this binding's property
396 : // hooks. And then structures which embedded a pointer to this structure
397 : // would require a run-time load for proper initialization, which would
398 : // then induce static constructors. Lots of static constructors.
399 : extern const NativePropertyHooks sNativePropertyHooks[];
400 :
401 : void
402 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
403 :
404 : JS::Handle<JSObject*>
405 : GetProtoObjectHandle(JSContext* aCx);
406 :
407 : JS::Handle<JSObject*>
408 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
409 :
410 : JSObject*
411 : GetConstructorObject(JSContext* aCx);
412 :
413 : } // namespace SVGPathSegCurvetoCubicSmoothRelBinding
414 :
415 :
416 :
417 : namespace SVGPathSegCurvetoQuadraticAbsBinding {
418 :
419 : typedef mozilla::DOMSVGPathSegCurvetoQuadraticAbs NativeType;
420 :
421 : JSObject*
422 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
423 :
424 : const JSClass*
425 : GetJSClass();
426 :
427 : bool
428 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoQuadraticAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
429 :
430 : template <class T>
431 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
432 : {
433 0 : JS::Rooted<JSObject*> reflector(aCx);
434 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
435 : }
436 :
437 : // We declare this as an array so that retrieving a pointer to this
438 : // binding's property hooks only requires compile/link-time resolvable
439 : // address arithmetic. Declaring it as a pointer instead would require
440 : // doing a run-time load to fetch a pointer to this binding's property
441 : // hooks. And then structures which embedded a pointer to this structure
442 : // would require a run-time load for proper initialization, which would
443 : // then induce static constructors. Lots of static constructors.
444 : extern const NativePropertyHooks sNativePropertyHooks[];
445 :
446 : void
447 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
448 :
449 : JS::Handle<JSObject*>
450 : GetProtoObjectHandle(JSContext* aCx);
451 :
452 : JS::Handle<JSObject*>
453 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
454 :
455 : JSObject*
456 : GetConstructorObject(JSContext* aCx);
457 :
458 : } // namespace SVGPathSegCurvetoQuadraticAbsBinding
459 :
460 :
461 :
462 : namespace SVGPathSegCurvetoQuadraticRelBinding {
463 :
464 : typedef mozilla::DOMSVGPathSegCurvetoQuadraticRel NativeType;
465 :
466 : JSObject*
467 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
468 :
469 : const JSClass*
470 : GetJSClass();
471 :
472 : bool
473 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoQuadraticRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
474 :
475 : template <class T>
476 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
477 : {
478 0 : JS::Rooted<JSObject*> reflector(aCx);
479 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
480 : }
481 :
482 : // We declare this as an array so that retrieving a pointer to this
483 : // binding's property hooks only requires compile/link-time resolvable
484 : // address arithmetic. Declaring it as a pointer instead would require
485 : // doing a run-time load to fetch a pointer to this binding's property
486 : // hooks. And then structures which embedded a pointer to this structure
487 : // would require a run-time load for proper initialization, which would
488 : // then induce static constructors. Lots of static constructors.
489 : extern const NativePropertyHooks sNativePropertyHooks[];
490 :
491 : void
492 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
493 :
494 : JS::Handle<JSObject*>
495 : GetProtoObjectHandle(JSContext* aCx);
496 :
497 : JS::Handle<JSObject*>
498 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
499 :
500 : JSObject*
501 : GetConstructorObject(JSContext* aCx);
502 :
503 : } // namespace SVGPathSegCurvetoQuadraticRelBinding
504 :
505 :
506 :
507 : namespace SVGPathSegCurvetoQuadraticSmoothAbsBinding {
508 :
509 : typedef mozilla::DOMSVGPathSegCurvetoQuadraticSmoothAbs NativeType;
510 :
511 : JSObject*
512 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
513 :
514 : const JSClass*
515 : GetJSClass();
516 :
517 : bool
518 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoQuadraticSmoothAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
519 :
520 : template <class T>
521 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
522 : {
523 0 : JS::Rooted<JSObject*> reflector(aCx);
524 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
525 : }
526 :
527 : // We declare this as an array so that retrieving a pointer to this
528 : // binding's property hooks only requires compile/link-time resolvable
529 : // address arithmetic. Declaring it as a pointer instead would require
530 : // doing a run-time load to fetch a pointer to this binding's property
531 : // hooks. And then structures which embedded a pointer to this structure
532 : // would require a run-time load for proper initialization, which would
533 : // then induce static constructors. Lots of static constructors.
534 : extern const NativePropertyHooks sNativePropertyHooks[];
535 :
536 : void
537 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
538 :
539 : JS::Handle<JSObject*>
540 : GetProtoObjectHandle(JSContext* aCx);
541 :
542 : JS::Handle<JSObject*>
543 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
544 :
545 : JSObject*
546 : GetConstructorObject(JSContext* aCx);
547 :
548 : } // namespace SVGPathSegCurvetoQuadraticSmoothAbsBinding
549 :
550 :
551 :
552 : namespace SVGPathSegCurvetoQuadraticSmoothRelBinding {
553 :
554 : typedef mozilla::DOMSVGPathSegCurvetoQuadraticSmoothRel NativeType;
555 :
556 : JSObject*
557 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
558 :
559 : const JSClass*
560 : GetJSClass();
561 :
562 : bool
563 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegCurvetoQuadraticSmoothRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
564 :
565 : template <class T>
566 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
567 : {
568 0 : JS::Rooted<JSObject*> reflector(aCx);
569 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
570 : }
571 :
572 : // We declare this as an array so that retrieving a pointer to this
573 : // binding's property hooks only requires compile/link-time resolvable
574 : // address arithmetic. Declaring it as a pointer instead would require
575 : // doing a run-time load to fetch a pointer to this binding's property
576 : // hooks. And then structures which embedded a pointer to this structure
577 : // would require a run-time load for proper initialization, which would
578 : // then induce static constructors. Lots of static constructors.
579 : extern const NativePropertyHooks sNativePropertyHooks[];
580 :
581 : void
582 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
583 :
584 : JS::Handle<JSObject*>
585 : GetProtoObjectHandle(JSContext* aCx);
586 :
587 : JS::Handle<JSObject*>
588 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
589 :
590 : JSObject*
591 : GetConstructorObject(JSContext* aCx);
592 :
593 : } // namespace SVGPathSegCurvetoQuadraticSmoothRelBinding
594 :
595 :
596 :
597 : namespace SVGPathSegLinetoAbsBinding {
598 :
599 : typedef mozilla::DOMSVGPathSegLinetoAbs NativeType;
600 :
601 : JSObject*
602 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
603 :
604 : const JSClass*
605 : GetJSClass();
606 :
607 : bool
608 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
609 :
610 : template <class T>
611 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
612 : {
613 0 : JS::Rooted<JSObject*> reflector(aCx);
614 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
615 : }
616 :
617 : // We declare this as an array so that retrieving a pointer to this
618 : // binding's property hooks only requires compile/link-time resolvable
619 : // address arithmetic. Declaring it as a pointer instead would require
620 : // doing a run-time load to fetch a pointer to this binding's property
621 : // hooks. And then structures which embedded a pointer to this structure
622 : // would require a run-time load for proper initialization, which would
623 : // then induce static constructors. Lots of static constructors.
624 : extern const NativePropertyHooks sNativePropertyHooks[];
625 :
626 : void
627 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
628 :
629 : JS::Handle<JSObject*>
630 : GetProtoObjectHandle(JSContext* aCx);
631 :
632 : JS::Handle<JSObject*>
633 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
634 :
635 : JSObject*
636 : GetConstructorObject(JSContext* aCx);
637 :
638 : } // namespace SVGPathSegLinetoAbsBinding
639 :
640 :
641 :
642 : namespace SVGPathSegLinetoHorizontalAbsBinding {
643 :
644 : typedef mozilla::DOMSVGPathSegLinetoHorizontalAbs NativeType;
645 :
646 : JSObject*
647 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
648 :
649 : const JSClass*
650 : GetJSClass();
651 :
652 : bool
653 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoHorizontalAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
654 :
655 : template <class T>
656 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
657 : {
658 0 : JS::Rooted<JSObject*> reflector(aCx);
659 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
660 : }
661 :
662 : // We declare this as an array so that retrieving a pointer to this
663 : // binding's property hooks only requires compile/link-time resolvable
664 : // address arithmetic. Declaring it as a pointer instead would require
665 : // doing a run-time load to fetch a pointer to this binding's property
666 : // hooks. And then structures which embedded a pointer to this structure
667 : // would require a run-time load for proper initialization, which would
668 : // then induce static constructors. Lots of static constructors.
669 : extern const NativePropertyHooks sNativePropertyHooks[];
670 :
671 : void
672 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
673 :
674 : JS::Handle<JSObject*>
675 : GetProtoObjectHandle(JSContext* aCx);
676 :
677 : JS::Handle<JSObject*>
678 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
679 :
680 : JSObject*
681 : GetConstructorObject(JSContext* aCx);
682 :
683 : } // namespace SVGPathSegLinetoHorizontalAbsBinding
684 :
685 :
686 :
687 : namespace SVGPathSegLinetoHorizontalRelBinding {
688 :
689 : typedef mozilla::DOMSVGPathSegLinetoHorizontalRel NativeType;
690 :
691 : JSObject*
692 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
693 :
694 : const JSClass*
695 : GetJSClass();
696 :
697 : bool
698 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoHorizontalRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
699 :
700 : template <class T>
701 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
702 : {
703 0 : JS::Rooted<JSObject*> reflector(aCx);
704 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
705 : }
706 :
707 : // We declare this as an array so that retrieving a pointer to this
708 : // binding's property hooks only requires compile/link-time resolvable
709 : // address arithmetic. Declaring it as a pointer instead would require
710 : // doing a run-time load to fetch a pointer to this binding's property
711 : // hooks. And then structures which embedded a pointer to this structure
712 : // would require a run-time load for proper initialization, which would
713 : // then induce static constructors. Lots of static constructors.
714 : extern const NativePropertyHooks sNativePropertyHooks[];
715 :
716 : void
717 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
718 :
719 : JS::Handle<JSObject*>
720 : GetProtoObjectHandle(JSContext* aCx);
721 :
722 : JS::Handle<JSObject*>
723 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
724 :
725 : JSObject*
726 : GetConstructorObject(JSContext* aCx);
727 :
728 : } // namespace SVGPathSegLinetoHorizontalRelBinding
729 :
730 :
731 :
732 : namespace SVGPathSegLinetoRelBinding {
733 :
734 : typedef mozilla::DOMSVGPathSegLinetoRel NativeType;
735 :
736 : JSObject*
737 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
738 :
739 : const JSClass*
740 : GetJSClass();
741 :
742 : bool
743 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
744 :
745 : template <class T>
746 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
747 : {
748 0 : JS::Rooted<JSObject*> reflector(aCx);
749 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
750 : }
751 :
752 : // We declare this as an array so that retrieving a pointer to this
753 : // binding's property hooks only requires compile/link-time resolvable
754 : // address arithmetic. Declaring it as a pointer instead would require
755 : // doing a run-time load to fetch a pointer to this binding's property
756 : // hooks. And then structures which embedded a pointer to this structure
757 : // would require a run-time load for proper initialization, which would
758 : // then induce static constructors. Lots of static constructors.
759 : extern const NativePropertyHooks sNativePropertyHooks[];
760 :
761 : void
762 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
763 :
764 : JS::Handle<JSObject*>
765 : GetProtoObjectHandle(JSContext* aCx);
766 :
767 : JS::Handle<JSObject*>
768 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
769 :
770 : JSObject*
771 : GetConstructorObject(JSContext* aCx);
772 :
773 : } // namespace SVGPathSegLinetoRelBinding
774 :
775 :
776 :
777 : namespace SVGPathSegLinetoVerticalAbsBinding {
778 :
779 : typedef mozilla::DOMSVGPathSegLinetoVerticalAbs NativeType;
780 :
781 : JSObject*
782 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
783 :
784 : const JSClass*
785 : GetJSClass();
786 :
787 : bool
788 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoVerticalAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
789 :
790 : template <class T>
791 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
792 : {
793 0 : JS::Rooted<JSObject*> reflector(aCx);
794 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
795 : }
796 :
797 : // We declare this as an array so that retrieving a pointer to this
798 : // binding's property hooks only requires compile/link-time resolvable
799 : // address arithmetic. Declaring it as a pointer instead would require
800 : // doing a run-time load to fetch a pointer to this binding's property
801 : // hooks. And then structures which embedded a pointer to this structure
802 : // would require a run-time load for proper initialization, which would
803 : // then induce static constructors. Lots of static constructors.
804 : extern const NativePropertyHooks sNativePropertyHooks[];
805 :
806 : void
807 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
808 :
809 : JS::Handle<JSObject*>
810 : GetProtoObjectHandle(JSContext* aCx);
811 :
812 : JS::Handle<JSObject*>
813 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
814 :
815 : JSObject*
816 : GetConstructorObject(JSContext* aCx);
817 :
818 : } // namespace SVGPathSegLinetoVerticalAbsBinding
819 :
820 :
821 :
822 : namespace SVGPathSegLinetoVerticalRelBinding {
823 :
824 : typedef mozilla::DOMSVGPathSegLinetoVerticalRel NativeType;
825 :
826 : JSObject*
827 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
828 :
829 : const JSClass*
830 : GetJSClass();
831 :
832 : bool
833 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegLinetoVerticalRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
834 :
835 : template <class T>
836 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
837 : {
838 0 : JS::Rooted<JSObject*> reflector(aCx);
839 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
840 : }
841 :
842 : // We declare this as an array so that retrieving a pointer to this
843 : // binding's property hooks only requires compile/link-time resolvable
844 : // address arithmetic. Declaring it as a pointer instead would require
845 : // doing a run-time load to fetch a pointer to this binding's property
846 : // hooks. And then structures which embedded a pointer to this structure
847 : // would require a run-time load for proper initialization, which would
848 : // then induce static constructors. Lots of static constructors.
849 : extern const NativePropertyHooks sNativePropertyHooks[];
850 :
851 : void
852 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
853 :
854 : JS::Handle<JSObject*>
855 : GetProtoObjectHandle(JSContext* aCx);
856 :
857 : JS::Handle<JSObject*>
858 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
859 :
860 : JSObject*
861 : GetConstructorObject(JSContext* aCx);
862 :
863 : } // namespace SVGPathSegLinetoVerticalRelBinding
864 :
865 :
866 :
867 : namespace SVGPathSegMovetoAbsBinding {
868 :
869 : typedef mozilla::DOMSVGPathSegMovetoAbs NativeType;
870 :
871 : JSObject*
872 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
873 :
874 : const JSClass*
875 : GetJSClass();
876 :
877 : bool
878 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegMovetoAbs* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
879 :
880 : template <class T>
881 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
882 : {
883 0 : JS::Rooted<JSObject*> reflector(aCx);
884 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
885 : }
886 :
887 : // We declare this as an array so that retrieving a pointer to this
888 : // binding's property hooks only requires compile/link-time resolvable
889 : // address arithmetic. Declaring it as a pointer instead would require
890 : // doing a run-time load to fetch a pointer to this binding's property
891 : // hooks. And then structures which embedded a pointer to this structure
892 : // would require a run-time load for proper initialization, which would
893 : // then induce static constructors. Lots of static constructors.
894 : extern const NativePropertyHooks sNativePropertyHooks[];
895 :
896 : void
897 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
898 :
899 : JS::Handle<JSObject*>
900 : GetProtoObjectHandle(JSContext* aCx);
901 :
902 : JS::Handle<JSObject*>
903 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
904 :
905 : JSObject*
906 : GetConstructorObject(JSContext* aCx);
907 :
908 : } // namespace SVGPathSegMovetoAbsBinding
909 :
910 :
911 :
912 : namespace SVGPathSegMovetoRelBinding {
913 :
914 : typedef mozilla::DOMSVGPathSegMovetoRel NativeType;
915 :
916 : JSObject*
917 : DefineDOMInterface(JSContext* aCx, JS::Handle<JSObject*> aGlobal, JS::Handle<jsid> id, bool aDefineOnGlobal);
918 :
919 : const JSClass*
920 : GetJSClass();
921 :
922 : bool
923 : Wrap(JSContext* aCx, mozilla::DOMSVGPathSegMovetoRel* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
924 :
925 : template <class T>
926 0 : inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
927 : {
928 0 : JS::Rooted<JSObject*> reflector(aCx);
929 0 : return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
930 : }
931 :
932 : // We declare this as an array so that retrieving a pointer to this
933 : // binding's property hooks only requires compile/link-time resolvable
934 : // address arithmetic. Declaring it as a pointer instead would require
935 : // doing a run-time load to fetch a pointer to this binding's property
936 : // hooks. And then structures which embedded a pointer to this structure
937 : // would require a run-time load for proper initialization, which would
938 : // then induce static constructors. Lots of static constructors.
939 : extern const NativePropertyHooks sNativePropertyHooks[];
940 :
941 : void
942 : CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
943 :
944 : JS::Handle<JSObject*>
945 : GetProtoObjectHandle(JSContext* aCx);
946 :
947 : JS::Handle<JSObject*>
948 : GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true);
949 :
950 : JSObject*
951 : GetConstructorObject(JSContext* aCx);
952 :
953 : } // namespace SVGPathSegMovetoRelBinding
954 :
955 :
956 :
957 : } // namespace dom
958 : } // namespace mozilla
959 :
960 : #endif // mozilla_dom_SVGPathSegBinding_h
|
