1 : /*
2 : * DO NOT EDIT. THIS FILE IS GENERATED FROM /builds/slave/m-beta-lnx-codecoverage/build/dom/interfaces/svg/nsIDOMSVGPathSeg.idl
3 : */
4 :
5 : #ifndef __gen_nsIDOMSVGPathSeg_h__
6 : #define __gen_nsIDOMSVGPathSeg_h__
7 :
8 :
9 : #ifndef __gen_domstubs_h__
10 : #include "domstubs.h"
11 : #endif
12 :
13 : /* For IDL files that don't want to include root IDL files. */
14 : #ifndef NS_NO_VTABLE
15 : #define NS_NO_VTABLE
16 : #endif
17 :
18 : /* starting interface: nsIDOMSVGPathSeg */
19 : #define NS_IDOMSVGPATHSEG_IID_STR "b9022da7-e26d-4df3-8c94-b45c4aedda7c"
20 :
21 : #define NS_IDOMSVGPATHSEG_IID \
22 : {0xb9022da7, 0xe26d, 0x4df3, \
23 : { 0x8c, 0x94, 0xb4, 0x5c, 0x4a, 0xed, 0xda, 0x7c }}
24 :
25 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSeg : public nsISupports {
26 : public:
27 :
28 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEG_IID)
29 :
30 : enum {
31 : PATHSEG_UNKNOWN = 0U,
32 : PATHSEG_CLOSEPATH = 1U,
33 : PATHSEG_MOVETO_ABS = 2U,
34 : PATHSEG_MOVETO_REL = 3U,
35 : PATHSEG_LINETO_ABS = 4U,
36 : PATHSEG_LINETO_REL = 5U,
37 : PATHSEG_CURVETO_CUBIC_ABS = 6U,
38 : PATHSEG_CURVETO_CUBIC_REL = 7U,
39 : PATHSEG_CURVETO_QUADRATIC_ABS = 8U,
40 : PATHSEG_CURVETO_QUADRATIC_REL = 9U,
41 : PATHSEG_ARC_ABS = 10U,
42 : PATHSEG_ARC_REL = 11U,
43 : PATHSEG_LINETO_HORIZONTAL_ABS = 12U,
44 : PATHSEG_LINETO_HORIZONTAL_REL = 13U,
45 : PATHSEG_LINETO_VERTICAL_ABS = 14U,
46 : PATHSEG_LINETO_VERTICAL_REL = 15U,
47 : PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16U,
48 : PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17U,
49 : PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18U,
50 : PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19U
51 : };
52 :
53 : /* readonly attribute unsigned short pathSegType; */
54 : NS_SCRIPTABLE NS_IMETHOD GetPathSegType(PRUint16 *aPathSegType) = 0;
55 :
56 : /* readonly attribute DOMString pathSegTypeAsLetter; */
57 : NS_SCRIPTABLE NS_IMETHOD GetPathSegTypeAsLetter(nsAString & aPathSegTypeAsLetter) = 0;
58 :
59 : };
60 :
61 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSeg, NS_IDOMSVGPATHSEG_IID)
62 :
63 : /* Use this macro when declaring classes that implement this interface. */
64 : #define NS_DECL_NSIDOMSVGPATHSEG \
65 : NS_SCRIPTABLE NS_IMETHOD GetPathSegType(PRUint16 *aPathSegType); \
66 : NS_SCRIPTABLE NS_IMETHOD GetPathSegTypeAsLetter(nsAString & aPathSegTypeAsLetter);
67 :
68 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
69 : #define NS_FORWARD_NSIDOMSVGPATHSEG(_to) \
70 : NS_SCRIPTABLE NS_IMETHOD GetPathSegType(PRUint16 *aPathSegType) { return _to GetPathSegType(aPathSegType); } \
71 : NS_SCRIPTABLE NS_IMETHOD GetPathSegTypeAsLetter(nsAString & aPathSegTypeAsLetter) { return _to GetPathSegTypeAsLetter(aPathSegTypeAsLetter); }
72 :
73 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
74 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEG(_to) \
75 : NS_SCRIPTABLE NS_IMETHOD GetPathSegType(PRUint16 *aPathSegType) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPathSegType(aPathSegType); } \
76 : NS_SCRIPTABLE NS_IMETHOD GetPathSegTypeAsLetter(nsAString & aPathSegTypeAsLetter) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPathSegTypeAsLetter(aPathSegTypeAsLetter); }
77 :
78 : #if 0
79 : /* Use the code below as a template for the implementation class for this interface. */
80 :
81 : /* Header file */
82 : class nsDOMSVGPathSeg : public nsIDOMSVGPathSeg
83 : {
84 : public:
85 : NS_DECL_ISUPPORTS
86 : NS_DECL_NSIDOMSVGPATHSEG
87 :
88 : nsDOMSVGPathSeg();
89 :
90 : private:
91 : ~nsDOMSVGPathSeg();
92 :
93 : protected:
94 : /* additional members */
95 : };
96 :
97 : /* Implementation file */
98 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSeg, nsIDOMSVGPathSeg)
99 :
100 : nsDOMSVGPathSeg::nsDOMSVGPathSeg()
101 : {
102 : /* member initializers and constructor code */
103 : }
104 :
105 : nsDOMSVGPathSeg::~nsDOMSVGPathSeg()
106 : {
107 : /* destructor code */
108 : }
109 :
110 : /* readonly attribute unsigned short pathSegType; */
111 : NS_IMETHODIMP nsDOMSVGPathSeg::GetPathSegType(PRUint16 *aPathSegType)
112 : {
113 : return NS_ERROR_NOT_IMPLEMENTED;
114 : }
115 :
116 : /* readonly attribute DOMString pathSegTypeAsLetter; */
117 : NS_IMETHODIMP nsDOMSVGPathSeg::GetPathSegTypeAsLetter(nsAString & aPathSegTypeAsLetter)
118 : {
119 : return NS_ERROR_NOT_IMPLEMENTED;
120 : }
121 :
122 : /* End of implementation class template. */
123 : #endif
124 :
125 :
126 : /* starting interface: nsIDOMSVGPathSegClosePath */
127 : #define NS_IDOMSVGPATHSEGCLOSEPATH_IID_STR "4970505f-2cc0-4afa-92e6-0cf4bdbf5a53"
128 :
129 : #define NS_IDOMSVGPATHSEGCLOSEPATH_IID \
130 : {0x4970505f, 0x2cc0, 0x4afa, \
131 : { 0x92, 0xe6, 0x0c, 0xf4, 0xbd, 0xbf, 0x5a, 0x53 }}
132 :
133 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegClosePath : public nsISupports {
134 : public:
135 :
136 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCLOSEPATH_IID)
137 :
138 : };
139 :
140 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegClosePath, NS_IDOMSVGPATHSEGCLOSEPATH_IID)
141 :
142 : /* Use this macro when declaring classes that implement this interface. */
143 : #define NS_DECL_NSIDOMSVGPATHSEGCLOSEPATH \
144 : /* no methods! */
145 :
146 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
147 : #define NS_FORWARD_NSIDOMSVGPATHSEGCLOSEPATH(_to) \
148 : /* no methods! */
149 :
150 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
151 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCLOSEPATH(_to) \
152 : /* no methods! */
153 :
154 : #if 0
155 : /* Use the code below as a template for the implementation class for this interface. */
156 :
157 : /* Header file */
158 : class nsDOMSVGPathSegClosePath : public nsIDOMSVGPathSegClosePath
159 : {
160 : public:
161 : NS_DECL_ISUPPORTS
162 : NS_DECL_NSIDOMSVGPATHSEGCLOSEPATH
163 :
164 : nsDOMSVGPathSegClosePath();
165 :
166 : private:
167 : ~nsDOMSVGPathSegClosePath();
168 :
169 : protected:
170 : /* additional members */
171 : };
172 :
173 : /* Implementation file */
174 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegClosePath, nsIDOMSVGPathSegClosePath)
175 :
176 : nsDOMSVGPathSegClosePath::nsDOMSVGPathSegClosePath()
177 : {
178 : /* member initializers and constructor code */
179 : }
180 :
181 : nsDOMSVGPathSegClosePath::~nsDOMSVGPathSegClosePath()
182 : {
183 : /* destructor code */
184 : }
185 :
186 : /* End of implementation class template. */
187 : #endif
188 :
189 :
190 : /* starting interface: nsIDOMSVGPathSegMovetoAbs */
191 : #define NS_IDOMSVGPATHSEGMOVETOABS_IID_STR "30cf7749-bf1f-4f9c-9558-8ee24da3a22c"
192 :
193 : #define NS_IDOMSVGPATHSEGMOVETOABS_IID \
194 : {0x30cf7749, 0xbf1f, 0x4f9c, \
195 : { 0x95, 0x58, 0x8e, 0xe2, 0x4d, 0xa3, 0xa2, 0x2c }}
196 :
197 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegMovetoAbs : public nsISupports {
198 : public:
199 :
200 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGMOVETOABS_IID)
201 :
202 : /* attribute float x; */
203 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
204 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
205 :
206 : /* attribute float y; */
207 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
208 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
209 :
210 : };
211 :
212 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegMovetoAbs, NS_IDOMSVGPATHSEGMOVETOABS_IID)
213 :
214 : /* Use this macro when declaring classes that implement this interface. */
215 : #define NS_DECL_NSIDOMSVGPATHSEGMOVETOABS \
216 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
217 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
218 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
219 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY);
220 :
221 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
222 : #define NS_FORWARD_NSIDOMSVGPATHSEGMOVETOABS(_to) \
223 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
224 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
225 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
226 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); }
227 :
228 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
229 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGMOVETOABS(_to) \
230 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
231 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
232 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
233 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); }
234 :
235 : #if 0
236 : /* Use the code below as a template for the implementation class for this interface. */
237 :
238 : /* Header file */
239 : class nsDOMSVGPathSegMovetoAbs : public nsIDOMSVGPathSegMovetoAbs
240 : {
241 : public:
242 : NS_DECL_ISUPPORTS
243 : NS_DECL_NSIDOMSVGPATHSEGMOVETOABS
244 :
245 : nsDOMSVGPathSegMovetoAbs();
246 :
247 : private:
248 : ~nsDOMSVGPathSegMovetoAbs();
249 :
250 : protected:
251 : /* additional members */
252 : };
253 :
254 : /* Implementation file */
255 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegMovetoAbs, nsIDOMSVGPathSegMovetoAbs)
256 :
257 : nsDOMSVGPathSegMovetoAbs::nsDOMSVGPathSegMovetoAbs()
258 : {
259 : /* member initializers and constructor code */
260 : }
261 :
262 : nsDOMSVGPathSegMovetoAbs::~nsDOMSVGPathSegMovetoAbs()
263 : {
264 : /* destructor code */
265 : }
266 :
267 : /* attribute float x; */
268 : NS_IMETHODIMP nsDOMSVGPathSegMovetoAbs::GetX(float *aX)
269 : {
270 : return NS_ERROR_NOT_IMPLEMENTED;
271 : }
272 : NS_IMETHODIMP nsDOMSVGPathSegMovetoAbs::SetX(float aX)
273 : {
274 : return NS_ERROR_NOT_IMPLEMENTED;
275 : }
276 :
277 : /* attribute float y; */
278 : NS_IMETHODIMP nsDOMSVGPathSegMovetoAbs::GetY(float *aY)
279 : {
280 : return NS_ERROR_NOT_IMPLEMENTED;
281 : }
282 : NS_IMETHODIMP nsDOMSVGPathSegMovetoAbs::SetY(float aY)
283 : {
284 : return NS_ERROR_NOT_IMPLEMENTED;
285 : }
286 :
287 : /* End of implementation class template. */
288 : #endif
289 :
290 :
291 : /* starting interface: nsIDOMSVGPathSegMovetoRel */
292 : #define NS_IDOMSVGPATHSEGMOVETOREL_IID_STR "58ca7e86-661a-473a-96de-89682e7e24d6"
293 :
294 : #define NS_IDOMSVGPATHSEGMOVETOREL_IID \
295 : {0x58ca7e86, 0x661a, 0x473a, \
296 : { 0x96, 0xde, 0x89, 0x68, 0x2e, 0x7e, 0x24, 0xd6 }}
297 :
298 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegMovetoRel : public nsISupports {
299 : public:
300 :
301 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGMOVETOREL_IID)
302 :
303 : /* attribute float x; */
304 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
305 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
306 :
307 : /* attribute float y; */
308 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
309 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
310 :
311 : };
312 :
313 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegMovetoRel, NS_IDOMSVGPATHSEGMOVETOREL_IID)
314 :
315 : /* Use this macro when declaring classes that implement this interface. */
316 : #define NS_DECL_NSIDOMSVGPATHSEGMOVETOREL \
317 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
318 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
319 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
320 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY);
321 :
322 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
323 : #define NS_FORWARD_NSIDOMSVGPATHSEGMOVETOREL(_to) \
324 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
325 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
326 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
327 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); }
328 :
329 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
330 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGMOVETOREL(_to) \
331 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
332 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
333 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
334 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); }
335 :
336 : #if 0
337 : /* Use the code below as a template for the implementation class for this interface. */
338 :
339 : /* Header file */
340 : class nsDOMSVGPathSegMovetoRel : public nsIDOMSVGPathSegMovetoRel
341 : {
342 : public:
343 : NS_DECL_ISUPPORTS
344 : NS_DECL_NSIDOMSVGPATHSEGMOVETOREL
345 :
346 : nsDOMSVGPathSegMovetoRel();
347 :
348 : private:
349 : ~nsDOMSVGPathSegMovetoRel();
350 :
351 : protected:
352 : /* additional members */
353 : };
354 :
355 : /* Implementation file */
356 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegMovetoRel, nsIDOMSVGPathSegMovetoRel)
357 :
358 : nsDOMSVGPathSegMovetoRel::nsDOMSVGPathSegMovetoRel()
359 : {
360 : /* member initializers and constructor code */
361 : }
362 :
363 : nsDOMSVGPathSegMovetoRel::~nsDOMSVGPathSegMovetoRel()
364 : {
365 : /* destructor code */
366 : }
367 :
368 : /* attribute float x; */
369 : NS_IMETHODIMP nsDOMSVGPathSegMovetoRel::GetX(float *aX)
370 : {
371 : return NS_ERROR_NOT_IMPLEMENTED;
372 : }
373 : NS_IMETHODIMP nsDOMSVGPathSegMovetoRel::SetX(float aX)
374 : {
375 : return NS_ERROR_NOT_IMPLEMENTED;
376 : }
377 :
378 : /* attribute float y; */
379 : NS_IMETHODIMP nsDOMSVGPathSegMovetoRel::GetY(float *aY)
380 : {
381 : return NS_ERROR_NOT_IMPLEMENTED;
382 : }
383 : NS_IMETHODIMP nsDOMSVGPathSegMovetoRel::SetY(float aY)
384 : {
385 : return NS_ERROR_NOT_IMPLEMENTED;
386 : }
387 :
388 : /* End of implementation class template. */
389 : #endif
390 :
391 :
392 : /* starting interface: nsIDOMSVGPathSegLinetoAbs */
393 : #define NS_IDOMSVGPATHSEGLINETOABS_IID_STR "5c7ba7b0-c7c5-4a7b-bc1c-2d784153be77"
394 :
395 : #define NS_IDOMSVGPATHSEGLINETOABS_IID \
396 : {0x5c7ba7b0, 0xc7c5, 0x4a7b, \
397 : { 0xbc, 0x1c, 0x2d, 0x78, 0x41, 0x53, 0xbe, 0x77 }}
398 :
399 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegLinetoAbs : public nsISupports {
400 : public:
401 :
402 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOABS_IID)
403 :
404 : /* attribute float x; */
405 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
406 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
407 :
408 : /* attribute float y; */
409 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
410 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
411 :
412 : };
413 :
414 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegLinetoAbs, NS_IDOMSVGPATHSEGLINETOABS_IID)
415 :
416 : /* Use this macro when declaring classes that implement this interface. */
417 : #define NS_DECL_NSIDOMSVGPATHSEGLINETOABS \
418 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
419 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
420 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
421 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY);
422 :
423 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
424 : #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOABS(_to) \
425 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
426 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
427 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
428 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); }
429 :
430 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
431 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOABS(_to) \
432 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
433 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
434 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
435 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); }
436 :
437 : #if 0
438 : /* Use the code below as a template for the implementation class for this interface. */
439 :
440 : /* Header file */
441 : class nsDOMSVGPathSegLinetoAbs : public nsIDOMSVGPathSegLinetoAbs
442 : {
443 : public:
444 : NS_DECL_ISUPPORTS
445 : NS_DECL_NSIDOMSVGPATHSEGLINETOABS
446 :
447 : nsDOMSVGPathSegLinetoAbs();
448 :
449 : private:
450 : ~nsDOMSVGPathSegLinetoAbs();
451 :
452 : protected:
453 : /* additional members */
454 : };
455 :
456 : /* Implementation file */
457 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoAbs, nsIDOMSVGPathSegLinetoAbs)
458 :
459 : nsDOMSVGPathSegLinetoAbs::nsDOMSVGPathSegLinetoAbs()
460 : {
461 : /* member initializers and constructor code */
462 : }
463 :
464 : nsDOMSVGPathSegLinetoAbs::~nsDOMSVGPathSegLinetoAbs()
465 : {
466 : /* destructor code */
467 : }
468 :
469 : /* attribute float x; */
470 : NS_IMETHODIMP nsDOMSVGPathSegLinetoAbs::GetX(float *aX)
471 : {
472 : return NS_ERROR_NOT_IMPLEMENTED;
473 : }
474 : NS_IMETHODIMP nsDOMSVGPathSegLinetoAbs::SetX(float aX)
475 : {
476 : return NS_ERROR_NOT_IMPLEMENTED;
477 : }
478 :
479 : /* attribute float y; */
480 : NS_IMETHODIMP nsDOMSVGPathSegLinetoAbs::GetY(float *aY)
481 : {
482 : return NS_ERROR_NOT_IMPLEMENTED;
483 : }
484 : NS_IMETHODIMP nsDOMSVGPathSegLinetoAbs::SetY(float aY)
485 : {
486 : return NS_ERROR_NOT_IMPLEMENTED;
487 : }
488 :
489 : /* End of implementation class template. */
490 : #endif
491 :
492 :
493 : /* starting interface: nsIDOMSVGPathSegLinetoRel */
494 : #define NS_IDOMSVGPATHSEGLINETOREL_IID_STR "7933a81a-72c5-4489-ba64-5635f4c23063"
495 :
496 : #define NS_IDOMSVGPATHSEGLINETOREL_IID \
497 : {0x7933a81a, 0x72c5, 0x4489, \
498 : { 0xba, 0x64, 0x56, 0x35, 0xf4, 0xc2, 0x30, 0x63 }}
499 :
500 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegLinetoRel : public nsISupports {
501 : public:
502 :
503 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOREL_IID)
504 :
505 : /* attribute float x; */
506 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
507 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
508 :
509 : /* attribute float y; */
510 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
511 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
512 :
513 : };
514 :
515 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegLinetoRel, NS_IDOMSVGPATHSEGLINETOREL_IID)
516 :
517 : /* Use this macro when declaring classes that implement this interface. */
518 : #define NS_DECL_NSIDOMSVGPATHSEGLINETOREL \
519 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
520 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
521 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
522 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY);
523 :
524 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
525 : #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOREL(_to) \
526 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
527 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
528 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
529 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); }
530 :
531 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
532 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOREL(_to) \
533 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
534 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
535 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
536 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); }
537 :
538 : #if 0
539 : /* Use the code below as a template for the implementation class for this interface. */
540 :
541 : /* Header file */
542 : class nsDOMSVGPathSegLinetoRel : public nsIDOMSVGPathSegLinetoRel
543 : {
544 : public:
545 : NS_DECL_ISUPPORTS
546 : NS_DECL_NSIDOMSVGPATHSEGLINETOREL
547 :
548 : nsDOMSVGPathSegLinetoRel();
549 :
550 : private:
551 : ~nsDOMSVGPathSegLinetoRel();
552 :
553 : protected:
554 : /* additional members */
555 : };
556 :
557 : /* Implementation file */
558 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoRel, nsIDOMSVGPathSegLinetoRel)
559 :
560 : nsDOMSVGPathSegLinetoRel::nsDOMSVGPathSegLinetoRel()
561 : {
562 : /* member initializers and constructor code */
563 : }
564 :
565 : nsDOMSVGPathSegLinetoRel::~nsDOMSVGPathSegLinetoRel()
566 : {
567 : /* destructor code */
568 : }
569 :
570 : /* attribute float x; */
571 : NS_IMETHODIMP nsDOMSVGPathSegLinetoRel::GetX(float *aX)
572 : {
573 : return NS_ERROR_NOT_IMPLEMENTED;
574 : }
575 : NS_IMETHODIMP nsDOMSVGPathSegLinetoRel::SetX(float aX)
576 : {
577 : return NS_ERROR_NOT_IMPLEMENTED;
578 : }
579 :
580 : /* attribute float y; */
581 : NS_IMETHODIMP nsDOMSVGPathSegLinetoRel::GetY(float *aY)
582 : {
583 : return NS_ERROR_NOT_IMPLEMENTED;
584 : }
585 : NS_IMETHODIMP nsDOMSVGPathSegLinetoRel::SetY(float aY)
586 : {
587 : return NS_ERROR_NOT_IMPLEMENTED;
588 : }
589 :
590 : /* End of implementation class template. */
591 : #endif
592 :
593 :
594 : /* starting interface: nsIDOMSVGPathSegCurvetoCubicAbs */
595 : #define NS_IDOMSVGPATHSEGCURVETOCUBICABS_IID_STR "380afecd-f884-4da7-a0d7-5ffc4531b70b"
596 :
597 : #define NS_IDOMSVGPATHSEGCURVETOCUBICABS_IID \
598 : {0x380afecd, 0xf884, 0x4da7, \
599 : { 0xa0, 0xd7, 0x5f, 0xfc, 0x45, 0x31, 0xb7, 0x0b }}
600 :
601 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegCurvetoCubicAbs : public nsISupports {
602 : public:
603 :
604 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOCUBICABS_IID)
605 :
606 : /* attribute float x; */
607 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
608 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
609 :
610 : /* attribute float y; */
611 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
612 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
613 :
614 : /* attribute float x1; */
615 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) = 0;
616 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) = 0;
617 :
618 : /* attribute float y1; */
619 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) = 0;
620 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) = 0;
621 :
622 : /* attribute float x2; */
623 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) = 0;
624 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) = 0;
625 :
626 : /* attribute float y2; */
627 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) = 0;
628 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) = 0;
629 :
630 : };
631 :
632 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegCurvetoCubicAbs, NS_IDOMSVGPATHSEGCURVETOCUBICABS_IID)
633 :
634 : /* Use this macro when declaring classes that implement this interface. */
635 : #define NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICABS \
636 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
637 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
638 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
639 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY); \
640 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1); \
641 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1); \
642 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1); \
643 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1); \
644 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2); \
645 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2); \
646 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2); \
647 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2);
648 :
649 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
650 : #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOCUBICABS(_to) \
651 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
652 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
653 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
654 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
655 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) { return _to GetX1(aX1); } \
656 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) { return _to SetX1(aX1); } \
657 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) { return _to GetY1(aY1); } \
658 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) { return _to SetY1(aY1); } \
659 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) { return _to GetX2(aX2); } \
660 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) { return _to SetX2(aX2); } \
661 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) { return _to GetY2(aY2); } \
662 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) { return _to SetY2(aY2); }
663 :
664 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
665 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOCUBICABS(_to) \
666 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
667 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
668 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
669 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
670 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX1(aX1); } \
671 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX1(aX1); } \
672 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY1(aY1); } \
673 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY1(aY1); } \
674 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX2(aX2); } \
675 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX2(aX2); } \
676 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY2(aY2); } \
677 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY2(aY2); }
678 :
679 : #if 0
680 : /* Use the code below as a template for the implementation class for this interface. */
681 :
682 : /* Header file */
683 : class nsDOMSVGPathSegCurvetoCubicAbs : public nsIDOMSVGPathSegCurvetoCubicAbs
684 : {
685 : public:
686 : NS_DECL_ISUPPORTS
687 : NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICABS
688 :
689 : nsDOMSVGPathSegCurvetoCubicAbs();
690 :
691 : private:
692 : ~nsDOMSVGPathSegCurvetoCubicAbs();
693 :
694 : protected:
695 : /* additional members */
696 : };
697 :
698 : /* Implementation file */
699 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoCubicAbs, nsIDOMSVGPathSegCurvetoCubicAbs)
700 :
701 : nsDOMSVGPathSegCurvetoCubicAbs::nsDOMSVGPathSegCurvetoCubicAbs()
702 : {
703 : /* member initializers and constructor code */
704 : }
705 :
706 : nsDOMSVGPathSegCurvetoCubicAbs::~nsDOMSVGPathSegCurvetoCubicAbs()
707 : {
708 : /* destructor code */
709 : }
710 :
711 : /* attribute float x; */
712 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetX(float *aX)
713 : {
714 : return NS_ERROR_NOT_IMPLEMENTED;
715 : }
716 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetX(float aX)
717 : {
718 : return NS_ERROR_NOT_IMPLEMENTED;
719 : }
720 :
721 : /* attribute float y; */
722 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetY(float *aY)
723 : {
724 : return NS_ERROR_NOT_IMPLEMENTED;
725 : }
726 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetY(float aY)
727 : {
728 : return NS_ERROR_NOT_IMPLEMENTED;
729 : }
730 :
731 : /* attribute float x1; */
732 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetX1(float *aX1)
733 : {
734 : return NS_ERROR_NOT_IMPLEMENTED;
735 : }
736 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetX1(float aX1)
737 : {
738 : return NS_ERROR_NOT_IMPLEMENTED;
739 : }
740 :
741 : /* attribute float y1; */
742 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetY1(float *aY1)
743 : {
744 : return NS_ERROR_NOT_IMPLEMENTED;
745 : }
746 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetY1(float aY1)
747 : {
748 : return NS_ERROR_NOT_IMPLEMENTED;
749 : }
750 :
751 : /* attribute float x2; */
752 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetX2(float *aX2)
753 : {
754 : return NS_ERROR_NOT_IMPLEMENTED;
755 : }
756 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetX2(float aX2)
757 : {
758 : return NS_ERROR_NOT_IMPLEMENTED;
759 : }
760 :
761 : /* attribute float y2; */
762 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetY2(float *aY2)
763 : {
764 : return NS_ERROR_NOT_IMPLEMENTED;
765 : }
766 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetY2(float aY2)
767 : {
768 : return NS_ERROR_NOT_IMPLEMENTED;
769 : }
770 :
771 : /* End of implementation class template. */
772 : #endif
773 :
774 :
775 : /* starting interface: nsIDOMSVGPathSegCurvetoCubicRel */
776 : #define NS_IDOMSVGPATHSEGCURVETOCUBICREL_IID_STR "0e661233-0c4f-4e0d-94d3-fbc460ad1f88"
777 :
778 : #define NS_IDOMSVGPATHSEGCURVETOCUBICREL_IID \
779 : {0x0e661233, 0x0c4f, 0x4e0d, \
780 : { 0x94, 0xd3, 0xfb, 0xc4, 0x60, 0xad, 0x1f, 0x88 }}
781 :
782 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegCurvetoCubicRel : public nsISupports {
783 : public:
784 :
785 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOCUBICREL_IID)
786 :
787 : /* attribute float x; */
788 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
789 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
790 :
791 : /* attribute float y; */
792 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
793 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
794 :
795 : /* attribute float x1; */
796 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) = 0;
797 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) = 0;
798 :
799 : /* attribute float y1; */
800 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) = 0;
801 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) = 0;
802 :
803 : /* attribute float x2; */
804 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) = 0;
805 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) = 0;
806 :
807 : /* attribute float y2; */
808 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) = 0;
809 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) = 0;
810 :
811 : };
812 :
813 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegCurvetoCubicRel, NS_IDOMSVGPATHSEGCURVETOCUBICREL_IID)
814 :
815 : /* Use this macro when declaring classes that implement this interface. */
816 : #define NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICREL \
817 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
818 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
819 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
820 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY); \
821 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1); \
822 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1); \
823 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1); \
824 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1); \
825 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2); \
826 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2); \
827 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2); \
828 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2);
829 :
830 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
831 : #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOCUBICREL(_to) \
832 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
833 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
834 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
835 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
836 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) { return _to GetX1(aX1); } \
837 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) { return _to SetX1(aX1); } \
838 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) { return _to GetY1(aY1); } \
839 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) { return _to SetY1(aY1); } \
840 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) { return _to GetX2(aX2); } \
841 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) { return _to SetX2(aX2); } \
842 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) { return _to GetY2(aY2); } \
843 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) { return _to SetY2(aY2); }
844 :
845 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
846 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOCUBICREL(_to) \
847 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
848 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
849 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
850 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
851 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX1(aX1); } \
852 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX1(aX1); } \
853 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY1(aY1); } \
854 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY1(aY1); } \
855 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX2(aX2); } \
856 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX2(aX2); } \
857 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY2(aY2); } \
858 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY2(aY2); }
859 :
860 : #if 0
861 : /* Use the code below as a template for the implementation class for this interface. */
862 :
863 : /* Header file */
864 : class nsDOMSVGPathSegCurvetoCubicRel : public nsIDOMSVGPathSegCurvetoCubicRel
865 : {
866 : public:
867 : NS_DECL_ISUPPORTS
868 : NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICREL
869 :
870 : nsDOMSVGPathSegCurvetoCubicRel();
871 :
872 : private:
873 : ~nsDOMSVGPathSegCurvetoCubicRel();
874 :
875 : protected:
876 : /* additional members */
877 : };
878 :
879 : /* Implementation file */
880 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoCubicRel, nsIDOMSVGPathSegCurvetoCubicRel)
881 :
882 : nsDOMSVGPathSegCurvetoCubicRel::nsDOMSVGPathSegCurvetoCubicRel()
883 : {
884 : /* member initializers and constructor code */
885 : }
886 :
887 : nsDOMSVGPathSegCurvetoCubicRel::~nsDOMSVGPathSegCurvetoCubicRel()
888 : {
889 : /* destructor code */
890 : }
891 :
892 : /* attribute float x; */
893 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetX(float *aX)
894 : {
895 : return NS_ERROR_NOT_IMPLEMENTED;
896 : }
897 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetX(float aX)
898 : {
899 : return NS_ERROR_NOT_IMPLEMENTED;
900 : }
901 :
902 : /* attribute float y; */
903 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetY(float *aY)
904 : {
905 : return NS_ERROR_NOT_IMPLEMENTED;
906 : }
907 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetY(float aY)
908 : {
909 : return NS_ERROR_NOT_IMPLEMENTED;
910 : }
911 :
912 : /* attribute float x1; */
913 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetX1(float *aX1)
914 : {
915 : return NS_ERROR_NOT_IMPLEMENTED;
916 : }
917 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetX1(float aX1)
918 : {
919 : return NS_ERROR_NOT_IMPLEMENTED;
920 : }
921 :
922 : /* attribute float y1; */
923 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetY1(float *aY1)
924 : {
925 : return NS_ERROR_NOT_IMPLEMENTED;
926 : }
927 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetY1(float aY1)
928 : {
929 : return NS_ERROR_NOT_IMPLEMENTED;
930 : }
931 :
932 : /* attribute float x2; */
933 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetX2(float *aX2)
934 : {
935 : return NS_ERROR_NOT_IMPLEMENTED;
936 : }
937 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetX2(float aX2)
938 : {
939 : return NS_ERROR_NOT_IMPLEMENTED;
940 : }
941 :
942 : /* attribute float y2; */
943 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetY2(float *aY2)
944 : {
945 : return NS_ERROR_NOT_IMPLEMENTED;
946 : }
947 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetY2(float aY2)
948 : {
949 : return NS_ERROR_NOT_IMPLEMENTED;
950 : }
951 :
952 : /* End of implementation class template. */
953 : #endif
954 :
955 :
956 : /* starting interface: nsIDOMSVGPathSegCurvetoQuadraticAbs */
957 : #define NS_IDOMSVGPATHSEGCURVETOQUADRATICABS_IID_STR "b7aef0f0-2830-4145-b04f-fe05789ccf8a"
958 :
959 : #define NS_IDOMSVGPATHSEGCURVETOQUADRATICABS_IID \
960 : {0xb7aef0f0, 0x2830, 0x4145, \
961 : { 0xb0, 0x4f, 0xfe, 0x05, 0x78, 0x9c, 0xcf, 0x8a }}
962 :
963 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegCurvetoQuadraticAbs : public nsISupports {
964 : public:
965 :
966 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOQUADRATICABS_IID)
967 :
968 : /* attribute float x; */
969 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
970 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
971 :
972 : /* attribute float y; */
973 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
974 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
975 :
976 : /* attribute float x1; */
977 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) = 0;
978 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) = 0;
979 :
980 : /* attribute float y1; */
981 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) = 0;
982 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) = 0;
983 :
984 : };
985 :
986 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegCurvetoQuadraticAbs, NS_IDOMSVGPATHSEGCURVETOQUADRATICABS_IID)
987 :
988 : /* Use this macro when declaring classes that implement this interface. */
989 : #define NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICABS \
990 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
991 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
992 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
993 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY); \
994 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1); \
995 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1); \
996 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1); \
997 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1);
998 :
999 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
1000 : #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOQUADRATICABS(_to) \
1001 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
1002 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
1003 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
1004 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
1005 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) { return _to GetX1(aX1); } \
1006 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) { return _to SetX1(aX1); } \
1007 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) { return _to GetY1(aY1); } \
1008 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) { return _to SetY1(aY1); }
1009 :
1010 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
1011 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOQUADRATICABS(_to) \
1012 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
1013 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
1014 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
1015 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
1016 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX1(aX1); } \
1017 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX1(aX1); } \
1018 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY1(aY1); } \
1019 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY1(aY1); }
1020 :
1021 : #if 0
1022 : /* Use the code below as a template for the implementation class for this interface. */
1023 :
1024 : /* Header file */
1025 : class nsDOMSVGPathSegCurvetoQuadraticAbs : public nsIDOMSVGPathSegCurvetoQuadraticAbs
1026 : {
1027 : public:
1028 : NS_DECL_ISUPPORTS
1029 : NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICABS
1030 :
1031 : nsDOMSVGPathSegCurvetoQuadraticAbs();
1032 :
1033 : private:
1034 : ~nsDOMSVGPathSegCurvetoQuadraticAbs();
1035 :
1036 : protected:
1037 : /* additional members */
1038 : };
1039 :
1040 : /* Implementation file */
1041 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoQuadraticAbs, nsIDOMSVGPathSegCurvetoQuadraticAbs)
1042 :
1043 : nsDOMSVGPathSegCurvetoQuadraticAbs::nsDOMSVGPathSegCurvetoQuadraticAbs()
1044 : {
1045 : /* member initializers and constructor code */
1046 : }
1047 :
1048 : nsDOMSVGPathSegCurvetoQuadraticAbs::~nsDOMSVGPathSegCurvetoQuadraticAbs()
1049 : {
1050 : /* destructor code */
1051 : }
1052 :
1053 : /* attribute float x; */
1054 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::GetX(float *aX)
1055 : {
1056 : return NS_ERROR_NOT_IMPLEMENTED;
1057 : }
1058 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::SetX(float aX)
1059 : {
1060 : return NS_ERROR_NOT_IMPLEMENTED;
1061 : }
1062 :
1063 : /* attribute float y; */
1064 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::GetY(float *aY)
1065 : {
1066 : return NS_ERROR_NOT_IMPLEMENTED;
1067 : }
1068 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::SetY(float aY)
1069 : {
1070 : return NS_ERROR_NOT_IMPLEMENTED;
1071 : }
1072 :
1073 : /* attribute float x1; */
1074 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::GetX1(float *aX1)
1075 : {
1076 : return NS_ERROR_NOT_IMPLEMENTED;
1077 : }
1078 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::SetX1(float aX1)
1079 : {
1080 : return NS_ERROR_NOT_IMPLEMENTED;
1081 : }
1082 :
1083 : /* attribute float y1; */
1084 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::GetY1(float *aY1)
1085 : {
1086 : return NS_ERROR_NOT_IMPLEMENTED;
1087 : }
1088 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::SetY1(float aY1)
1089 : {
1090 : return NS_ERROR_NOT_IMPLEMENTED;
1091 : }
1092 :
1093 : /* End of implementation class template. */
1094 : #endif
1095 :
1096 :
1097 : /* starting interface: nsIDOMSVGPathSegCurvetoQuadraticRel */
1098 : #define NS_IDOMSVGPATHSEGCURVETOQUADRATICREL_IID_STR "c46eb661-9c05-4d46-9b2a-c2ae5b166060"
1099 :
1100 : #define NS_IDOMSVGPATHSEGCURVETOQUADRATICREL_IID \
1101 : {0xc46eb661, 0x9c05, 0x4d46, \
1102 : { 0x9b, 0x2a, 0xc2, 0xae, 0x5b, 0x16, 0x60, 0x60 }}
1103 :
1104 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegCurvetoQuadraticRel : public nsISupports {
1105 : public:
1106 :
1107 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOQUADRATICREL_IID)
1108 :
1109 : /* attribute float x; */
1110 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
1111 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
1112 :
1113 : /* attribute float y; */
1114 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
1115 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
1116 :
1117 : /* attribute float x1; */
1118 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) = 0;
1119 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) = 0;
1120 :
1121 : /* attribute float y1; */
1122 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) = 0;
1123 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) = 0;
1124 :
1125 : };
1126 :
1127 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegCurvetoQuadraticRel, NS_IDOMSVGPATHSEGCURVETOQUADRATICREL_IID)
1128 :
1129 : /* Use this macro when declaring classes that implement this interface. */
1130 : #define NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICREL \
1131 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
1132 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
1133 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
1134 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY); \
1135 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1); \
1136 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1); \
1137 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1); \
1138 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1);
1139 :
1140 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
1141 : #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOQUADRATICREL(_to) \
1142 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
1143 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
1144 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
1145 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
1146 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) { return _to GetX1(aX1); } \
1147 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) { return _to SetX1(aX1); } \
1148 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) { return _to GetY1(aY1); } \
1149 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) { return _to SetY1(aY1); }
1150 :
1151 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
1152 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOQUADRATICREL(_to) \
1153 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
1154 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
1155 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
1156 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
1157 : NS_SCRIPTABLE NS_IMETHOD GetX1(float *aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX1(aX1); } \
1158 : NS_SCRIPTABLE NS_IMETHOD SetX1(float aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX1(aX1); } \
1159 : NS_SCRIPTABLE NS_IMETHOD GetY1(float *aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY1(aY1); } \
1160 : NS_SCRIPTABLE NS_IMETHOD SetY1(float aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY1(aY1); }
1161 :
1162 : #if 0
1163 : /* Use the code below as a template for the implementation class for this interface. */
1164 :
1165 : /* Header file */
1166 : class nsDOMSVGPathSegCurvetoQuadraticRel : public nsIDOMSVGPathSegCurvetoQuadraticRel
1167 : {
1168 : public:
1169 : NS_DECL_ISUPPORTS
1170 : NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICREL
1171 :
1172 : nsDOMSVGPathSegCurvetoQuadraticRel();
1173 :
1174 : private:
1175 : ~nsDOMSVGPathSegCurvetoQuadraticRel();
1176 :
1177 : protected:
1178 : /* additional members */
1179 : };
1180 :
1181 : /* Implementation file */
1182 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoQuadraticRel, nsIDOMSVGPathSegCurvetoQuadraticRel)
1183 :
1184 : nsDOMSVGPathSegCurvetoQuadraticRel::nsDOMSVGPathSegCurvetoQuadraticRel()
1185 : {
1186 : /* member initializers and constructor code */
1187 : }
1188 :
1189 : nsDOMSVGPathSegCurvetoQuadraticRel::~nsDOMSVGPathSegCurvetoQuadraticRel()
1190 : {
1191 : /* destructor code */
1192 : }
1193 :
1194 : /* attribute float x; */
1195 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::GetX(float *aX)
1196 : {
1197 : return NS_ERROR_NOT_IMPLEMENTED;
1198 : }
1199 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::SetX(float aX)
1200 : {
1201 : return NS_ERROR_NOT_IMPLEMENTED;
1202 : }
1203 :
1204 : /* attribute float y; */
1205 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::GetY(float *aY)
1206 : {
1207 : return NS_ERROR_NOT_IMPLEMENTED;
1208 : }
1209 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::SetY(float aY)
1210 : {
1211 : return NS_ERROR_NOT_IMPLEMENTED;
1212 : }
1213 :
1214 : /* attribute float x1; */
1215 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::GetX1(float *aX1)
1216 : {
1217 : return NS_ERROR_NOT_IMPLEMENTED;
1218 : }
1219 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::SetX1(float aX1)
1220 : {
1221 : return NS_ERROR_NOT_IMPLEMENTED;
1222 : }
1223 :
1224 : /* attribute float y1; */
1225 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::GetY1(float *aY1)
1226 : {
1227 : return NS_ERROR_NOT_IMPLEMENTED;
1228 : }
1229 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::SetY1(float aY1)
1230 : {
1231 : return NS_ERROR_NOT_IMPLEMENTED;
1232 : }
1233 :
1234 : /* End of implementation class template. */
1235 : #endif
1236 :
1237 :
1238 : /* starting interface: nsIDOMSVGPathSegArcAbs */
1239 : #define NS_IDOMSVGPATHSEGARCABS_IID_STR "c9e222e5-31fd-4083-ae1f-fcf013681340"
1240 :
1241 : #define NS_IDOMSVGPATHSEGARCABS_IID \
1242 : {0xc9e222e5, 0x31fd, 0x4083, \
1243 : { 0xae, 0x1f, 0xfc, 0xf0, 0x13, 0x68, 0x13, 0x40 }}
1244 :
1245 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegArcAbs : public nsISupports {
1246 : public:
1247 :
1248 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGARCABS_IID)
1249 :
1250 : /* attribute float x; */
1251 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
1252 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
1253 :
1254 : /* attribute float y; */
1255 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
1256 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
1257 :
1258 : /* attribute float r1; */
1259 : NS_SCRIPTABLE NS_IMETHOD GetR1(float *aR1) = 0;
1260 : NS_SCRIPTABLE NS_IMETHOD SetR1(float aR1) = 0;
1261 :
1262 : /* attribute float r2; */
1263 : NS_SCRIPTABLE NS_IMETHOD GetR2(float *aR2) = 0;
1264 : NS_SCRIPTABLE NS_IMETHOD SetR2(float aR2) = 0;
1265 :
1266 : /* attribute float angle; */
1267 : NS_SCRIPTABLE NS_IMETHOD GetAngle(float *aAngle) = 0;
1268 : NS_SCRIPTABLE NS_IMETHOD SetAngle(float aAngle) = 0;
1269 :
1270 : /* attribute boolean largeArcFlag; */
1271 : NS_SCRIPTABLE NS_IMETHOD GetLargeArcFlag(bool *aLargeArcFlag) = 0;
1272 : NS_SCRIPTABLE NS_IMETHOD SetLargeArcFlag(bool aLargeArcFlag) = 0;
1273 :
1274 : /* attribute boolean sweepFlag; */
1275 : NS_SCRIPTABLE NS_IMETHOD GetSweepFlag(bool *aSweepFlag) = 0;
1276 : NS_SCRIPTABLE NS_IMETHOD SetSweepFlag(bool aSweepFlag) = 0;
1277 :
1278 : };
1279 :
1280 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegArcAbs, NS_IDOMSVGPATHSEGARCABS_IID)
1281 :
1282 : /* Use this macro when declaring classes that implement this interface. */
1283 : #define NS_DECL_NSIDOMSVGPATHSEGARCABS \
1284 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
1285 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
1286 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
1287 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY); \
1288 : NS_SCRIPTABLE NS_IMETHOD GetR1(float *aR1); \
1289 : NS_SCRIPTABLE NS_IMETHOD SetR1(float aR1); \
1290 : NS_SCRIPTABLE NS_IMETHOD GetR2(float *aR2); \
1291 : NS_SCRIPTABLE NS_IMETHOD SetR2(float aR2); \
1292 : NS_SCRIPTABLE NS_IMETHOD GetAngle(float *aAngle); \
1293 : NS_SCRIPTABLE NS_IMETHOD SetAngle(float aAngle); \
1294 : NS_SCRIPTABLE NS_IMETHOD GetLargeArcFlag(bool *aLargeArcFlag); \
1295 : NS_SCRIPTABLE NS_IMETHOD SetLargeArcFlag(bool aLargeArcFlag); \
1296 : NS_SCRIPTABLE NS_IMETHOD GetSweepFlag(bool *aSweepFlag); \
1297 : NS_SCRIPTABLE NS_IMETHOD SetSweepFlag(bool aSweepFlag);
1298 :
1299 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
1300 : #define NS_FORWARD_NSIDOMSVGPATHSEGARCABS(_to) \
1301 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
1302 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
1303 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
1304 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
1305 : NS_SCRIPTABLE NS_IMETHOD GetR1(float *aR1) { return _to GetR1(aR1); } \
1306 : NS_SCRIPTABLE NS_IMETHOD SetR1(float aR1) { return _to SetR1(aR1); } \
1307 : NS_SCRIPTABLE NS_IMETHOD GetR2(float *aR2) { return _to GetR2(aR2); } \
1308 : NS_SCRIPTABLE NS_IMETHOD SetR2(float aR2) { return _to SetR2(aR2); } \
1309 : NS_SCRIPTABLE NS_IMETHOD GetAngle(float *aAngle) { return _to GetAngle(aAngle); } \
1310 : NS_SCRIPTABLE NS_IMETHOD SetAngle(float aAngle) { return _to SetAngle(aAngle); } \
1311 : NS_SCRIPTABLE NS_IMETHOD GetLargeArcFlag(bool *aLargeArcFlag) { return _to GetLargeArcFlag(aLargeArcFlag); } \
1312 : NS_SCRIPTABLE NS_IMETHOD SetLargeArcFlag(bool aLargeArcFlag) { return _to SetLargeArcFlag(aLargeArcFlag); } \
1313 : NS_SCRIPTABLE NS_IMETHOD GetSweepFlag(bool *aSweepFlag) { return _to GetSweepFlag(aSweepFlag); } \
1314 : NS_SCRIPTABLE NS_IMETHOD SetSweepFlag(bool aSweepFlag) { return _to SetSweepFlag(aSweepFlag); }
1315 :
1316 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
1317 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGARCABS(_to) \
1318 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
1319 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
1320 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
1321 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
1322 : NS_SCRIPTABLE NS_IMETHOD GetR1(float *aR1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetR1(aR1); } \
1323 : NS_SCRIPTABLE NS_IMETHOD SetR1(float aR1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetR1(aR1); } \
1324 : NS_SCRIPTABLE NS_IMETHOD GetR2(float *aR2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetR2(aR2); } \
1325 : NS_SCRIPTABLE NS_IMETHOD SetR2(float aR2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetR2(aR2); } \
1326 : NS_SCRIPTABLE NS_IMETHOD GetAngle(float *aAngle) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAngle(aAngle); } \
1327 : NS_SCRIPTABLE NS_IMETHOD SetAngle(float aAngle) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAngle(aAngle); } \
1328 : NS_SCRIPTABLE NS_IMETHOD GetLargeArcFlag(bool *aLargeArcFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetLargeArcFlag(aLargeArcFlag); } \
1329 : NS_SCRIPTABLE NS_IMETHOD SetLargeArcFlag(bool aLargeArcFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetLargeArcFlag(aLargeArcFlag); } \
1330 : NS_SCRIPTABLE NS_IMETHOD GetSweepFlag(bool *aSweepFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSweepFlag(aSweepFlag); } \
1331 : NS_SCRIPTABLE NS_IMETHOD SetSweepFlag(bool aSweepFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSweepFlag(aSweepFlag); }
1332 :
1333 : #if 0
1334 : /* Use the code below as a template for the implementation class for this interface. */
1335 :
1336 : /* Header file */
1337 : class nsDOMSVGPathSegArcAbs : public nsIDOMSVGPathSegArcAbs
1338 : {
1339 : public:
1340 : NS_DECL_ISUPPORTS
1341 : NS_DECL_NSIDOMSVGPATHSEGARCABS
1342 :
1343 : nsDOMSVGPathSegArcAbs();
1344 :
1345 : private:
1346 : ~nsDOMSVGPathSegArcAbs();
1347 :
1348 : protected:
1349 : /* additional members */
1350 : };
1351 :
1352 : /* Implementation file */
1353 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegArcAbs, nsIDOMSVGPathSegArcAbs)
1354 :
1355 : nsDOMSVGPathSegArcAbs::nsDOMSVGPathSegArcAbs()
1356 : {
1357 : /* member initializers and constructor code */
1358 : }
1359 :
1360 : nsDOMSVGPathSegArcAbs::~nsDOMSVGPathSegArcAbs()
1361 : {
1362 : /* destructor code */
1363 : }
1364 :
1365 : /* attribute float x; */
1366 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetX(float *aX)
1367 : {
1368 : return NS_ERROR_NOT_IMPLEMENTED;
1369 : }
1370 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetX(float aX)
1371 : {
1372 : return NS_ERROR_NOT_IMPLEMENTED;
1373 : }
1374 :
1375 : /* attribute float y; */
1376 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetY(float *aY)
1377 : {
1378 : return NS_ERROR_NOT_IMPLEMENTED;
1379 : }
1380 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetY(float aY)
1381 : {
1382 : return NS_ERROR_NOT_IMPLEMENTED;
1383 : }
1384 :
1385 : /* attribute float r1; */
1386 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetR1(float *aR1)
1387 : {
1388 : return NS_ERROR_NOT_IMPLEMENTED;
1389 : }
1390 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetR1(float aR1)
1391 : {
1392 : return NS_ERROR_NOT_IMPLEMENTED;
1393 : }
1394 :
1395 : /* attribute float r2; */
1396 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetR2(float *aR2)
1397 : {
1398 : return NS_ERROR_NOT_IMPLEMENTED;
1399 : }
1400 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetR2(float aR2)
1401 : {
1402 : return NS_ERROR_NOT_IMPLEMENTED;
1403 : }
1404 :
1405 : /* attribute float angle; */
1406 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetAngle(float *aAngle)
1407 : {
1408 : return NS_ERROR_NOT_IMPLEMENTED;
1409 : }
1410 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetAngle(float aAngle)
1411 : {
1412 : return NS_ERROR_NOT_IMPLEMENTED;
1413 : }
1414 :
1415 : /* attribute boolean largeArcFlag; */
1416 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetLargeArcFlag(bool *aLargeArcFlag)
1417 : {
1418 : return NS_ERROR_NOT_IMPLEMENTED;
1419 : }
1420 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetLargeArcFlag(bool aLargeArcFlag)
1421 : {
1422 : return NS_ERROR_NOT_IMPLEMENTED;
1423 : }
1424 :
1425 : /* attribute boolean sweepFlag; */
1426 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetSweepFlag(bool *aSweepFlag)
1427 : {
1428 : return NS_ERROR_NOT_IMPLEMENTED;
1429 : }
1430 : NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetSweepFlag(bool aSweepFlag)
1431 : {
1432 : return NS_ERROR_NOT_IMPLEMENTED;
1433 : }
1434 :
1435 : /* End of implementation class template. */
1436 : #endif
1437 :
1438 :
1439 : /* starting interface: nsIDOMSVGPathSegArcRel */
1440 : #define NS_IDOMSVGPATHSEGARCREL_IID_STR "49d0360d-bb66-4ab9-b9b0-f49b93398595"
1441 :
1442 : #define NS_IDOMSVGPATHSEGARCREL_IID \
1443 : {0x49d0360d, 0xbb66, 0x4ab9, \
1444 : { 0xb9, 0xb0, 0xf4, 0x9b, 0x93, 0x39, 0x85, 0x95 }}
1445 :
1446 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegArcRel : public nsISupports {
1447 : public:
1448 :
1449 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGARCREL_IID)
1450 :
1451 : /* attribute float x; */
1452 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
1453 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
1454 :
1455 : /* attribute float y; */
1456 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
1457 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
1458 :
1459 : /* attribute float r1; */
1460 : NS_SCRIPTABLE NS_IMETHOD GetR1(float *aR1) = 0;
1461 : NS_SCRIPTABLE NS_IMETHOD SetR1(float aR1) = 0;
1462 :
1463 : /* attribute float r2; */
1464 : NS_SCRIPTABLE NS_IMETHOD GetR2(float *aR2) = 0;
1465 : NS_SCRIPTABLE NS_IMETHOD SetR2(float aR2) = 0;
1466 :
1467 : /* attribute float angle; */
1468 : NS_SCRIPTABLE NS_IMETHOD GetAngle(float *aAngle) = 0;
1469 : NS_SCRIPTABLE NS_IMETHOD SetAngle(float aAngle) = 0;
1470 :
1471 : /* attribute boolean largeArcFlag; */
1472 : NS_SCRIPTABLE NS_IMETHOD GetLargeArcFlag(bool *aLargeArcFlag) = 0;
1473 : NS_SCRIPTABLE NS_IMETHOD SetLargeArcFlag(bool aLargeArcFlag) = 0;
1474 :
1475 : /* attribute boolean sweepFlag; */
1476 : NS_SCRIPTABLE NS_IMETHOD GetSweepFlag(bool *aSweepFlag) = 0;
1477 : NS_SCRIPTABLE NS_IMETHOD SetSweepFlag(bool aSweepFlag) = 0;
1478 :
1479 : };
1480 :
1481 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegArcRel, NS_IDOMSVGPATHSEGARCREL_IID)
1482 :
1483 : /* Use this macro when declaring classes that implement this interface. */
1484 : #define NS_DECL_NSIDOMSVGPATHSEGARCREL \
1485 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
1486 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
1487 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
1488 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY); \
1489 : NS_SCRIPTABLE NS_IMETHOD GetR1(float *aR1); \
1490 : NS_SCRIPTABLE NS_IMETHOD SetR1(float aR1); \
1491 : NS_SCRIPTABLE NS_IMETHOD GetR2(float *aR2); \
1492 : NS_SCRIPTABLE NS_IMETHOD SetR2(float aR2); \
1493 : NS_SCRIPTABLE NS_IMETHOD GetAngle(float *aAngle); \
1494 : NS_SCRIPTABLE NS_IMETHOD SetAngle(float aAngle); \
1495 : NS_SCRIPTABLE NS_IMETHOD GetLargeArcFlag(bool *aLargeArcFlag); \
1496 : NS_SCRIPTABLE NS_IMETHOD SetLargeArcFlag(bool aLargeArcFlag); \
1497 : NS_SCRIPTABLE NS_IMETHOD GetSweepFlag(bool *aSweepFlag); \
1498 : NS_SCRIPTABLE NS_IMETHOD SetSweepFlag(bool aSweepFlag);
1499 :
1500 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
1501 : #define NS_FORWARD_NSIDOMSVGPATHSEGARCREL(_to) \
1502 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
1503 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
1504 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
1505 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
1506 : NS_SCRIPTABLE NS_IMETHOD GetR1(float *aR1) { return _to GetR1(aR1); } \
1507 : NS_SCRIPTABLE NS_IMETHOD SetR1(float aR1) { return _to SetR1(aR1); } \
1508 : NS_SCRIPTABLE NS_IMETHOD GetR2(float *aR2) { return _to GetR2(aR2); } \
1509 : NS_SCRIPTABLE NS_IMETHOD SetR2(float aR2) { return _to SetR2(aR2); } \
1510 : NS_SCRIPTABLE NS_IMETHOD GetAngle(float *aAngle) { return _to GetAngle(aAngle); } \
1511 : NS_SCRIPTABLE NS_IMETHOD SetAngle(float aAngle) { return _to SetAngle(aAngle); } \
1512 : NS_SCRIPTABLE NS_IMETHOD GetLargeArcFlag(bool *aLargeArcFlag) { return _to GetLargeArcFlag(aLargeArcFlag); } \
1513 : NS_SCRIPTABLE NS_IMETHOD SetLargeArcFlag(bool aLargeArcFlag) { return _to SetLargeArcFlag(aLargeArcFlag); } \
1514 : NS_SCRIPTABLE NS_IMETHOD GetSweepFlag(bool *aSweepFlag) { return _to GetSweepFlag(aSweepFlag); } \
1515 : NS_SCRIPTABLE NS_IMETHOD SetSweepFlag(bool aSweepFlag) { return _to SetSweepFlag(aSweepFlag); }
1516 :
1517 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
1518 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGARCREL(_to) \
1519 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
1520 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
1521 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
1522 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
1523 : NS_SCRIPTABLE NS_IMETHOD GetR1(float *aR1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetR1(aR1); } \
1524 : NS_SCRIPTABLE NS_IMETHOD SetR1(float aR1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetR1(aR1); } \
1525 : NS_SCRIPTABLE NS_IMETHOD GetR2(float *aR2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetR2(aR2); } \
1526 : NS_SCRIPTABLE NS_IMETHOD SetR2(float aR2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetR2(aR2); } \
1527 : NS_SCRIPTABLE NS_IMETHOD GetAngle(float *aAngle) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAngle(aAngle); } \
1528 : NS_SCRIPTABLE NS_IMETHOD SetAngle(float aAngle) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAngle(aAngle); } \
1529 : NS_SCRIPTABLE NS_IMETHOD GetLargeArcFlag(bool *aLargeArcFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetLargeArcFlag(aLargeArcFlag); } \
1530 : NS_SCRIPTABLE NS_IMETHOD SetLargeArcFlag(bool aLargeArcFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetLargeArcFlag(aLargeArcFlag); } \
1531 : NS_SCRIPTABLE NS_IMETHOD GetSweepFlag(bool *aSweepFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSweepFlag(aSweepFlag); } \
1532 : NS_SCRIPTABLE NS_IMETHOD SetSweepFlag(bool aSweepFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSweepFlag(aSweepFlag); }
1533 :
1534 : #if 0
1535 : /* Use the code below as a template for the implementation class for this interface. */
1536 :
1537 : /* Header file */
1538 : class nsDOMSVGPathSegArcRel : public nsIDOMSVGPathSegArcRel
1539 : {
1540 : public:
1541 : NS_DECL_ISUPPORTS
1542 : NS_DECL_NSIDOMSVGPATHSEGARCREL
1543 :
1544 : nsDOMSVGPathSegArcRel();
1545 :
1546 : private:
1547 : ~nsDOMSVGPathSegArcRel();
1548 :
1549 : protected:
1550 : /* additional members */
1551 : };
1552 :
1553 : /* Implementation file */
1554 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegArcRel, nsIDOMSVGPathSegArcRel)
1555 :
1556 : nsDOMSVGPathSegArcRel::nsDOMSVGPathSegArcRel()
1557 : {
1558 : /* member initializers and constructor code */
1559 : }
1560 :
1561 : nsDOMSVGPathSegArcRel::~nsDOMSVGPathSegArcRel()
1562 : {
1563 : /* destructor code */
1564 : }
1565 :
1566 : /* attribute float x; */
1567 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetX(float *aX)
1568 : {
1569 : return NS_ERROR_NOT_IMPLEMENTED;
1570 : }
1571 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetX(float aX)
1572 : {
1573 : return NS_ERROR_NOT_IMPLEMENTED;
1574 : }
1575 :
1576 : /* attribute float y; */
1577 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetY(float *aY)
1578 : {
1579 : return NS_ERROR_NOT_IMPLEMENTED;
1580 : }
1581 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetY(float aY)
1582 : {
1583 : return NS_ERROR_NOT_IMPLEMENTED;
1584 : }
1585 :
1586 : /* attribute float r1; */
1587 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetR1(float *aR1)
1588 : {
1589 : return NS_ERROR_NOT_IMPLEMENTED;
1590 : }
1591 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetR1(float aR1)
1592 : {
1593 : return NS_ERROR_NOT_IMPLEMENTED;
1594 : }
1595 :
1596 : /* attribute float r2; */
1597 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetR2(float *aR2)
1598 : {
1599 : return NS_ERROR_NOT_IMPLEMENTED;
1600 : }
1601 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetR2(float aR2)
1602 : {
1603 : return NS_ERROR_NOT_IMPLEMENTED;
1604 : }
1605 :
1606 : /* attribute float angle; */
1607 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetAngle(float *aAngle)
1608 : {
1609 : return NS_ERROR_NOT_IMPLEMENTED;
1610 : }
1611 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetAngle(float aAngle)
1612 : {
1613 : return NS_ERROR_NOT_IMPLEMENTED;
1614 : }
1615 :
1616 : /* attribute boolean largeArcFlag; */
1617 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetLargeArcFlag(bool *aLargeArcFlag)
1618 : {
1619 : return NS_ERROR_NOT_IMPLEMENTED;
1620 : }
1621 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetLargeArcFlag(bool aLargeArcFlag)
1622 : {
1623 : return NS_ERROR_NOT_IMPLEMENTED;
1624 : }
1625 :
1626 : /* attribute boolean sweepFlag; */
1627 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetSweepFlag(bool *aSweepFlag)
1628 : {
1629 : return NS_ERROR_NOT_IMPLEMENTED;
1630 : }
1631 : NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetSweepFlag(bool aSweepFlag)
1632 : {
1633 : return NS_ERROR_NOT_IMPLEMENTED;
1634 : }
1635 :
1636 : /* End of implementation class template. */
1637 : #endif
1638 :
1639 :
1640 : /* starting interface: nsIDOMSVGPathSegLinetoHorizontalAbs */
1641 : #define NS_IDOMSVGPATHSEGLINETOHORIZONTALABS_IID_STR "4a54a4d2-edef-4e19-9600-2330311000f4"
1642 :
1643 : #define NS_IDOMSVGPATHSEGLINETOHORIZONTALABS_IID \
1644 : {0x4a54a4d2, 0xedef, 0x4e19, \
1645 : { 0x96, 0x00, 0x23, 0x30, 0x31, 0x10, 0x00, 0xf4 }}
1646 :
1647 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegLinetoHorizontalAbs : public nsISupports {
1648 : public:
1649 :
1650 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOHORIZONTALABS_IID)
1651 :
1652 : /* attribute float x; */
1653 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
1654 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
1655 :
1656 : };
1657 :
1658 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegLinetoHorizontalAbs, NS_IDOMSVGPATHSEGLINETOHORIZONTALABS_IID)
1659 :
1660 : /* Use this macro when declaring classes that implement this interface. */
1661 : #define NS_DECL_NSIDOMSVGPATHSEGLINETOHORIZONTALABS \
1662 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
1663 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX);
1664 :
1665 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
1666 : #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOHORIZONTALABS(_to) \
1667 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
1668 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); }
1669 :
1670 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
1671 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOHORIZONTALABS(_to) \
1672 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
1673 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); }
1674 :
1675 : #if 0
1676 : /* Use the code below as a template for the implementation class for this interface. */
1677 :
1678 : /* Header file */
1679 : class nsDOMSVGPathSegLinetoHorizontalAbs : public nsIDOMSVGPathSegLinetoHorizontalAbs
1680 : {
1681 : public:
1682 : NS_DECL_ISUPPORTS
1683 : NS_DECL_NSIDOMSVGPATHSEGLINETOHORIZONTALABS
1684 :
1685 : nsDOMSVGPathSegLinetoHorizontalAbs();
1686 :
1687 : private:
1688 : ~nsDOMSVGPathSegLinetoHorizontalAbs();
1689 :
1690 : protected:
1691 : /* additional members */
1692 : };
1693 :
1694 : /* Implementation file */
1695 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoHorizontalAbs, nsIDOMSVGPathSegLinetoHorizontalAbs)
1696 :
1697 : nsDOMSVGPathSegLinetoHorizontalAbs::nsDOMSVGPathSegLinetoHorizontalAbs()
1698 : {
1699 : /* member initializers and constructor code */
1700 : }
1701 :
1702 : nsDOMSVGPathSegLinetoHorizontalAbs::~nsDOMSVGPathSegLinetoHorizontalAbs()
1703 : {
1704 : /* destructor code */
1705 : }
1706 :
1707 : /* attribute float x; */
1708 : NS_IMETHODIMP nsDOMSVGPathSegLinetoHorizontalAbs::GetX(float *aX)
1709 : {
1710 : return NS_ERROR_NOT_IMPLEMENTED;
1711 : }
1712 : NS_IMETHODIMP nsDOMSVGPathSegLinetoHorizontalAbs::SetX(float aX)
1713 : {
1714 : return NS_ERROR_NOT_IMPLEMENTED;
1715 : }
1716 :
1717 : /* End of implementation class template. */
1718 : #endif
1719 :
1720 :
1721 : /* starting interface: nsIDOMSVGPathSegLinetoHorizontalRel */
1722 : #define NS_IDOMSVGPATHSEGLINETOHORIZONTALREL_IID_STR "8693268c-5180-43fd-acc3-5b9c09f43386"
1723 :
1724 : #define NS_IDOMSVGPATHSEGLINETOHORIZONTALREL_IID \
1725 : {0x8693268c, 0x5180, 0x43fd, \
1726 : { 0xac, 0xc3, 0x5b, 0x9c, 0x09, 0xf4, 0x33, 0x86 }}
1727 :
1728 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegLinetoHorizontalRel : public nsISupports {
1729 : public:
1730 :
1731 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOHORIZONTALREL_IID)
1732 :
1733 : /* attribute float x; */
1734 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
1735 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
1736 :
1737 : };
1738 :
1739 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegLinetoHorizontalRel, NS_IDOMSVGPATHSEGLINETOHORIZONTALREL_IID)
1740 :
1741 : /* Use this macro when declaring classes that implement this interface. */
1742 : #define NS_DECL_NSIDOMSVGPATHSEGLINETOHORIZONTALREL \
1743 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
1744 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX);
1745 :
1746 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
1747 : #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOHORIZONTALREL(_to) \
1748 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
1749 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); }
1750 :
1751 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
1752 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOHORIZONTALREL(_to) \
1753 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
1754 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); }
1755 :
1756 : #if 0
1757 : /* Use the code below as a template for the implementation class for this interface. */
1758 :
1759 : /* Header file */
1760 : class nsDOMSVGPathSegLinetoHorizontalRel : public nsIDOMSVGPathSegLinetoHorizontalRel
1761 : {
1762 : public:
1763 : NS_DECL_ISUPPORTS
1764 : NS_DECL_NSIDOMSVGPATHSEGLINETOHORIZONTALREL
1765 :
1766 : nsDOMSVGPathSegLinetoHorizontalRel();
1767 :
1768 : private:
1769 : ~nsDOMSVGPathSegLinetoHorizontalRel();
1770 :
1771 : protected:
1772 : /* additional members */
1773 : };
1774 :
1775 : /* Implementation file */
1776 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoHorizontalRel, nsIDOMSVGPathSegLinetoHorizontalRel)
1777 :
1778 : nsDOMSVGPathSegLinetoHorizontalRel::nsDOMSVGPathSegLinetoHorizontalRel()
1779 : {
1780 : /* member initializers and constructor code */
1781 : }
1782 :
1783 : nsDOMSVGPathSegLinetoHorizontalRel::~nsDOMSVGPathSegLinetoHorizontalRel()
1784 : {
1785 : /* destructor code */
1786 : }
1787 :
1788 : /* attribute float x; */
1789 : NS_IMETHODIMP nsDOMSVGPathSegLinetoHorizontalRel::GetX(float *aX)
1790 : {
1791 : return NS_ERROR_NOT_IMPLEMENTED;
1792 : }
1793 : NS_IMETHODIMP nsDOMSVGPathSegLinetoHorizontalRel::SetX(float aX)
1794 : {
1795 : return NS_ERROR_NOT_IMPLEMENTED;
1796 : }
1797 :
1798 : /* End of implementation class template. */
1799 : #endif
1800 :
1801 :
1802 : /* starting interface: nsIDOMSVGPathSegLinetoVerticalAbs */
1803 : #define NS_IDOMSVGPATHSEGLINETOVERTICALABS_IID_STR "fd5ffb7b-7279-4c09-abfd-b733dc872e80"
1804 :
1805 : #define NS_IDOMSVGPATHSEGLINETOVERTICALABS_IID \
1806 : {0xfd5ffb7b, 0x7279, 0x4c09, \
1807 : { 0xab, 0xfd, 0xb7, 0x33, 0xdc, 0x87, 0x2e, 0x80 }}
1808 :
1809 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegLinetoVerticalAbs : public nsISupports {
1810 : public:
1811 :
1812 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOVERTICALABS_IID)
1813 :
1814 : /* attribute float y; */
1815 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
1816 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
1817 :
1818 : };
1819 :
1820 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegLinetoVerticalAbs, NS_IDOMSVGPATHSEGLINETOVERTICALABS_IID)
1821 :
1822 : /* Use this macro when declaring classes that implement this interface. */
1823 : #define NS_DECL_NSIDOMSVGPATHSEGLINETOVERTICALABS \
1824 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
1825 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY);
1826 :
1827 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
1828 : #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOVERTICALABS(_to) \
1829 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
1830 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); }
1831 :
1832 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
1833 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOVERTICALABS(_to) \
1834 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
1835 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); }
1836 :
1837 : #if 0
1838 : /* Use the code below as a template for the implementation class for this interface. */
1839 :
1840 : /* Header file */
1841 : class nsDOMSVGPathSegLinetoVerticalAbs : public nsIDOMSVGPathSegLinetoVerticalAbs
1842 : {
1843 : public:
1844 : NS_DECL_ISUPPORTS
1845 : NS_DECL_NSIDOMSVGPATHSEGLINETOVERTICALABS
1846 :
1847 : nsDOMSVGPathSegLinetoVerticalAbs();
1848 :
1849 : private:
1850 : ~nsDOMSVGPathSegLinetoVerticalAbs();
1851 :
1852 : protected:
1853 : /* additional members */
1854 : };
1855 :
1856 : /* Implementation file */
1857 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoVerticalAbs, nsIDOMSVGPathSegLinetoVerticalAbs)
1858 :
1859 : nsDOMSVGPathSegLinetoVerticalAbs::nsDOMSVGPathSegLinetoVerticalAbs()
1860 : {
1861 : /* member initializers and constructor code */
1862 : }
1863 :
1864 : nsDOMSVGPathSegLinetoVerticalAbs::~nsDOMSVGPathSegLinetoVerticalAbs()
1865 : {
1866 : /* destructor code */
1867 : }
1868 :
1869 : /* attribute float y; */
1870 : NS_IMETHODIMP nsDOMSVGPathSegLinetoVerticalAbs::GetY(float *aY)
1871 : {
1872 : return NS_ERROR_NOT_IMPLEMENTED;
1873 : }
1874 : NS_IMETHODIMP nsDOMSVGPathSegLinetoVerticalAbs::SetY(float aY)
1875 : {
1876 : return NS_ERROR_NOT_IMPLEMENTED;
1877 : }
1878 :
1879 : /* End of implementation class template. */
1880 : #endif
1881 :
1882 :
1883 : /* starting interface: nsIDOMSVGPathSegLinetoVerticalRel */
1884 : #define NS_IDOMSVGPATHSEGLINETOVERTICALREL_IID_STR "d3ef2128-8de3-4aac-a6b4-13c7563119a6"
1885 :
1886 : #define NS_IDOMSVGPATHSEGLINETOVERTICALREL_IID \
1887 : {0xd3ef2128, 0x8de3, 0x4aac, \
1888 : { 0xa6, 0xb4, 0x13, 0xc7, 0x56, 0x31, 0x19, 0xa6 }}
1889 :
1890 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegLinetoVerticalRel : public nsISupports {
1891 : public:
1892 :
1893 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOVERTICALREL_IID)
1894 :
1895 : /* attribute float y; */
1896 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
1897 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
1898 :
1899 : };
1900 :
1901 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegLinetoVerticalRel, NS_IDOMSVGPATHSEGLINETOVERTICALREL_IID)
1902 :
1903 : /* Use this macro when declaring classes that implement this interface. */
1904 : #define NS_DECL_NSIDOMSVGPATHSEGLINETOVERTICALREL \
1905 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
1906 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY);
1907 :
1908 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
1909 : #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOVERTICALREL(_to) \
1910 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
1911 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); }
1912 :
1913 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
1914 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOVERTICALREL(_to) \
1915 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
1916 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); }
1917 :
1918 : #if 0
1919 : /* Use the code below as a template for the implementation class for this interface. */
1920 :
1921 : /* Header file */
1922 : class nsDOMSVGPathSegLinetoVerticalRel : public nsIDOMSVGPathSegLinetoVerticalRel
1923 : {
1924 : public:
1925 : NS_DECL_ISUPPORTS
1926 : NS_DECL_NSIDOMSVGPATHSEGLINETOVERTICALREL
1927 :
1928 : nsDOMSVGPathSegLinetoVerticalRel();
1929 :
1930 : private:
1931 : ~nsDOMSVGPathSegLinetoVerticalRel();
1932 :
1933 : protected:
1934 : /* additional members */
1935 : };
1936 :
1937 : /* Implementation file */
1938 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoVerticalRel, nsIDOMSVGPathSegLinetoVerticalRel)
1939 :
1940 : nsDOMSVGPathSegLinetoVerticalRel::nsDOMSVGPathSegLinetoVerticalRel()
1941 : {
1942 : /* member initializers and constructor code */
1943 : }
1944 :
1945 : nsDOMSVGPathSegLinetoVerticalRel::~nsDOMSVGPathSegLinetoVerticalRel()
1946 : {
1947 : /* destructor code */
1948 : }
1949 :
1950 : /* attribute float y; */
1951 : NS_IMETHODIMP nsDOMSVGPathSegLinetoVerticalRel::GetY(float *aY)
1952 : {
1953 : return NS_ERROR_NOT_IMPLEMENTED;
1954 : }
1955 : NS_IMETHODIMP nsDOMSVGPathSegLinetoVerticalRel::SetY(float aY)
1956 : {
1957 : return NS_ERROR_NOT_IMPLEMENTED;
1958 : }
1959 :
1960 : /* End of implementation class template. */
1961 : #endif
1962 :
1963 :
1964 : /* starting interface: nsIDOMSVGPathSegCurvetoCubicSmoothAbs */
1965 : #define NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHABS_IID_STR "5fa8fea8-bdd1-4315-ac44-a39b3ff347b5"
1966 :
1967 : #define NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHABS_IID \
1968 : {0x5fa8fea8, 0xbdd1, 0x4315, \
1969 : { 0xac, 0x44, 0xa3, 0x9b, 0x3f, 0xf3, 0x47, 0xb5 }}
1970 :
1971 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegCurvetoCubicSmoothAbs : public nsISupports {
1972 : public:
1973 :
1974 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHABS_IID)
1975 :
1976 : /* attribute float x; */
1977 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
1978 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
1979 :
1980 : /* attribute float y; */
1981 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
1982 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
1983 :
1984 : /* attribute float x2; */
1985 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) = 0;
1986 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) = 0;
1987 :
1988 : /* attribute float y2; */
1989 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) = 0;
1990 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) = 0;
1991 :
1992 : };
1993 :
1994 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegCurvetoCubicSmoothAbs, NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHABS_IID)
1995 :
1996 : /* Use this macro when declaring classes that implement this interface. */
1997 : #define NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHABS \
1998 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
1999 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
2000 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
2001 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY); \
2002 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2); \
2003 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2); \
2004 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2); \
2005 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2);
2006 :
2007 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
2008 : #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHABS(_to) \
2009 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
2010 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
2011 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
2012 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
2013 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) { return _to GetX2(aX2); } \
2014 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) { return _to SetX2(aX2); } \
2015 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) { return _to GetY2(aY2); } \
2016 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) { return _to SetY2(aY2); }
2017 :
2018 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
2019 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHABS(_to) \
2020 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
2021 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
2022 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
2023 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
2024 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX2(aX2); } \
2025 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX2(aX2); } \
2026 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY2(aY2); } \
2027 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY2(aY2); }
2028 :
2029 : #if 0
2030 : /* Use the code below as a template for the implementation class for this interface. */
2031 :
2032 : /* Header file */
2033 : class nsDOMSVGPathSegCurvetoCubicSmoothAbs : public nsIDOMSVGPathSegCurvetoCubicSmoothAbs
2034 : {
2035 : public:
2036 : NS_DECL_ISUPPORTS
2037 : NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHABS
2038 :
2039 : nsDOMSVGPathSegCurvetoCubicSmoothAbs();
2040 :
2041 : private:
2042 : ~nsDOMSVGPathSegCurvetoCubicSmoothAbs();
2043 :
2044 : protected:
2045 : /* additional members */
2046 : };
2047 :
2048 : /* Implementation file */
2049 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoCubicSmoothAbs, nsIDOMSVGPathSegCurvetoCubicSmoothAbs)
2050 :
2051 : nsDOMSVGPathSegCurvetoCubicSmoothAbs::nsDOMSVGPathSegCurvetoCubicSmoothAbs()
2052 : {
2053 : /* member initializers and constructor code */
2054 : }
2055 :
2056 : nsDOMSVGPathSegCurvetoCubicSmoothAbs::~nsDOMSVGPathSegCurvetoCubicSmoothAbs()
2057 : {
2058 : /* destructor code */
2059 : }
2060 :
2061 : /* attribute float x; */
2062 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::GetX(float *aX)
2063 : {
2064 : return NS_ERROR_NOT_IMPLEMENTED;
2065 : }
2066 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::SetX(float aX)
2067 : {
2068 : return NS_ERROR_NOT_IMPLEMENTED;
2069 : }
2070 :
2071 : /* attribute float y; */
2072 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::GetY(float *aY)
2073 : {
2074 : return NS_ERROR_NOT_IMPLEMENTED;
2075 : }
2076 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::SetY(float aY)
2077 : {
2078 : return NS_ERROR_NOT_IMPLEMENTED;
2079 : }
2080 :
2081 : /* attribute float x2; */
2082 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::GetX2(float *aX2)
2083 : {
2084 : return NS_ERROR_NOT_IMPLEMENTED;
2085 : }
2086 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::SetX2(float aX2)
2087 : {
2088 : return NS_ERROR_NOT_IMPLEMENTED;
2089 : }
2090 :
2091 : /* attribute float y2; */
2092 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::GetY2(float *aY2)
2093 : {
2094 : return NS_ERROR_NOT_IMPLEMENTED;
2095 : }
2096 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::SetY2(float aY2)
2097 : {
2098 : return NS_ERROR_NOT_IMPLEMENTED;
2099 : }
2100 :
2101 : /* End of implementation class template. */
2102 : #endif
2103 :
2104 :
2105 : /* starting interface: nsIDOMSVGPathSegCurvetoCubicSmoothRel */
2106 : #define NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHREL_IID_STR "dd5b4b00-edaa-493a-b477-bbc2576b4a98"
2107 :
2108 : #define NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHREL_IID \
2109 : {0xdd5b4b00, 0xedaa, 0x493a, \
2110 : { 0xb4, 0x77, 0xbb, 0xc2, 0x57, 0x6b, 0x4a, 0x98 }}
2111 :
2112 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegCurvetoCubicSmoothRel : public nsISupports {
2113 : public:
2114 :
2115 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHREL_IID)
2116 :
2117 : /* attribute float x; */
2118 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
2119 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
2120 :
2121 : /* attribute float y; */
2122 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
2123 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
2124 :
2125 : /* attribute float x2; */
2126 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) = 0;
2127 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) = 0;
2128 :
2129 : /* attribute float y2; */
2130 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) = 0;
2131 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) = 0;
2132 :
2133 : };
2134 :
2135 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegCurvetoCubicSmoothRel, NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHREL_IID)
2136 :
2137 : /* Use this macro when declaring classes that implement this interface. */
2138 : #define NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHREL \
2139 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
2140 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
2141 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
2142 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY); \
2143 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2); \
2144 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2); \
2145 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2); \
2146 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2);
2147 :
2148 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
2149 : #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHREL(_to) \
2150 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
2151 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
2152 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
2153 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
2154 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) { return _to GetX2(aX2); } \
2155 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) { return _to SetX2(aX2); } \
2156 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) { return _to GetY2(aY2); } \
2157 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) { return _to SetY2(aY2); }
2158 :
2159 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
2160 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHREL(_to) \
2161 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
2162 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
2163 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
2164 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
2165 : NS_SCRIPTABLE NS_IMETHOD GetX2(float *aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX2(aX2); } \
2166 : NS_SCRIPTABLE NS_IMETHOD SetX2(float aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX2(aX2); } \
2167 : NS_SCRIPTABLE NS_IMETHOD GetY2(float *aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY2(aY2); } \
2168 : NS_SCRIPTABLE NS_IMETHOD SetY2(float aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY2(aY2); }
2169 :
2170 : #if 0
2171 : /* Use the code below as a template for the implementation class for this interface. */
2172 :
2173 : /* Header file */
2174 : class nsDOMSVGPathSegCurvetoCubicSmoothRel : public nsIDOMSVGPathSegCurvetoCubicSmoothRel
2175 : {
2176 : public:
2177 : NS_DECL_ISUPPORTS
2178 : NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHREL
2179 :
2180 : nsDOMSVGPathSegCurvetoCubicSmoothRel();
2181 :
2182 : private:
2183 : ~nsDOMSVGPathSegCurvetoCubicSmoothRel();
2184 :
2185 : protected:
2186 : /* additional members */
2187 : };
2188 :
2189 : /* Implementation file */
2190 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoCubicSmoothRel, nsIDOMSVGPathSegCurvetoCubicSmoothRel)
2191 :
2192 : nsDOMSVGPathSegCurvetoCubicSmoothRel::nsDOMSVGPathSegCurvetoCubicSmoothRel()
2193 : {
2194 : /* member initializers and constructor code */
2195 : }
2196 :
2197 : nsDOMSVGPathSegCurvetoCubicSmoothRel::~nsDOMSVGPathSegCurvetoCubicSmoothRel()
2198 : {
2199 : /* destructor code */
2200 : }
2201 :
2202 : /* attribute float x; */
2203 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::GetX(float *aX)
2204 : {
2205 : return NS_ERROR_NOT_IMPLEMENTED;
2206 : }
2207 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::SetX(float aX)
2208 : {
2209 : return NS_ERROR_NOT_IMPLEMENTED;
2210 : }
2211 :
2212 : /* attribute float y; */
2213 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::GetY(float *aY)
2214 : {
2215 : return NS_ERROR_NOT_IMPLEMENTED;
2216 : }
2217 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::SetY(float aY)
2218 : {
2219 : return NS_ERROR_NOT_IMPLEMENTED;
2220 : }
2221 :
2222 : /* attribute float x2; */
2223 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::GetX2(float *aX2)
2224 : {
2225 : return NS_ERROR_NOT_IMPLEMENTED;
2226 : }
2227 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::SetX2(float aX2)
2228 : {
2229 : return NS_ERROR_NOT_IMPLEMENTED;
2230 : }
2231 :
2232 : /* attribute float y2; */
2233 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::GetY2(float *aY2)
2234 : {
2235 : return NS_ERROR_NOT_IMPLEMENTED;
2236 : }
2237 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::SetY2(float aY2)
2238 : {
2239 : return NS_ERROR_NOT_IMPLEMENTED;
2240 : }
2241 :
2242 : /* End of implementation class template. */
2243 : #endif
2244 :
2245 :
2246 : /* starting interface: nsIDOMSVGPathSegCurvetoQuadraticSmoothAbs */
2247 : #define NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS_IID_STR "ff5bbb58-b49a-450f-b91b-e50585c34b3d"
2248 :
2249 : #define NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS_IID \
2250 : {0xff5bbb58, 0xb49a, 0x450f, \
2251 : { 0xb9, 0x1b, 0xe5, 0x05, 0x85, 0xc3, 0x4b, 0x3d }}
2252 :
2253 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegCurvetoQuadraticSmoothAbs : public nsISupports {
2254 : public:
2255 :
2256 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS_IID)
2257 :
2258 : /* attribute float x; */
2259 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
2260 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
2261 :
2262 : /* attribute float y; */
2263 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
2264 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
2265 :
2266 : };
2267 :
2268 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegCurvetoQuadraticSmoothAbs, NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS_IID)
2269 :
2270 : /* Use this macro when declaring classes that implement this interface. */
2271 : #define NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS \
2272 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
2273 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
2274 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
2275 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY);
2276 :
2277 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
2278 : #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS(_to) \
2279 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
2280 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
2281 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
2282 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); }
2283 :
2284 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
2285 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS(_to) \
2286 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
2287 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
2288 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
2289 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); }
2290 :
2291 : #if 0
2292 : /* Use the code below as a template for the implementation class for this interface. */
2293 :
2294 : /* Header file */
2295 : class nsDOMSVGPathSegCurvetoQuadraticSmoothAbs : public nsIDOMSVGPathSegCurvetoQuadraticSmoothAbs
2296 : {
2297 : public:
2298 : NS_DECL_ISUPPORTS
2299 : NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS
2300 :
2301 : nsDOMSVGPathSegCurvetoQuadraticSmoothAbs();
2302 :
2303 : private:
2304 : ~nsDOMSVGPathSegCurvetoQuadraticSmoothAbs();
2305 :
2306 : protected:
2307 : /* additional members */
2308 : };
2309 :
2310 : /* Implementation file */
2311 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoQuadraticSmoothAbs, nsIDOMSVGPathSegCurvetoQuadraticSmoothAbs)
2312 :
2313 : nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::nsDOMSVGPathSegCurvetoQuadraticSmoothAbs()
2314 : {
2315 : /* member initializers and constructor code */
2316 : }
2317 :
2318 : nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::~nsDOMSVGPathSegCurvetoQuadraticSmoothAbs()
2319 : {
2320 : /* destructor code */
2321 : }
2322 :
2323 : /* attribute float x; */
2324 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::GetX(float *aX)
2325 : {
2326 : return NS_ERROR_NOT_IMPLEMENTED;
2327 : }
2328 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::SetX(float aX)
2329 : {
2330 : return NS_ERROR_NOT_IMPLEMENTED;
2331 : }
2332 :
2333 : /* attribute float y; */
2334 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::GetY(float *aY)
2335 : {
2336 : return NS_ERROR_NOT_IMPLEMENTED;
2337 : }
2338 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::SetY(float aY)
2339 : {
2340 : return NS_ERROR_NOT_IMPLEMENTED;
2341 : }
2342 :
2343 : /* End of implementation class template. */
2344 : #endif
2345 :
2346 :
2347 : /* starting interface: nsIDOMSVGPathSegCurvetoQuadraticSmoothRel */
2348 : #define NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL_IID_STR "ac0b2007-04e4-4e70-a0e0-294f374b29c4"
2349 :
2350 : #define NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL_IID \
2351 : {0xac0b2007, 0x04e4, 0x4e70, \
2352 : { 0xa0, 0xe0, 0x29, 0x4f, 0x37, 0x4b, 0x29, 0xc4 }}
2353 :
2354 0 : class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMSVGPathSegCurvetoQuadraticSmoothRel : public nsISupports {
2355 : public:
2356 :
2357 : NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL_IID)
2358 :
2359 : /* attribute float x; */
2360 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) = 0;
2361 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) = 0;
2362 :
2363 : /* attribute float y; */
2364 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) = 0;
2365 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) = 0;
2366 :
2367 : };
2368 :
2369 : NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMSVGPathSegCurvetoQuadraticSmoothRel, NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL_IID)
2370 :
2371 : /* Use this macro when declaring classes that implement this interface. */
2372 : #define NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL \
2373 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX); \
2374 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX); \
2375 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY); \
2376 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY);
2377 :
2378 : /* Use this macro to declare functions that forward the behavior of this interface to another object. */
2379 : #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL(_to) \
2380 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
2381 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
2382 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
2383 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return _to SetY(aY); }
2384 :
2385 : /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
2386 : #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL(_to) \
2387 : NS_SCRIPTABLE NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
2388 : NS_SCRIPTABLE NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
2389 : NS_SCRIPTABLE NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
2390 : NS_SCRIPTABLE NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); }
2391 :
2392 : #if 0
2393 : /* Use the code below as a template for the implementation class for this interface. */
2394 :
2395 : /* Header file */
2396 : class nsDOMSVGPathSegCurvetoQuadraticSmoothRel : public nsIDOMSVGPathSegCurvetoQuadraticSmoothRel
2397 : {
2398 : public:
2399 : NS_DECL_ISUPPORTS
2400 : NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL
2401 :
2402 : nsDOMSVGPathSegCurvetoQuadraticSmoothRel();
2403 :
2404 : private:
2405 : ~nsDOMSVGPathSegCurvetoQuadraticSmoothRel();
2406 :
2407 : protected:
2408 : /* additional members */
2409 : };
2410 :
2411 : /* Implementation file */
2412 : NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoQuadraticSmoothRel, nsIDOMSVGPathSegCurvetoQuadraticSmoothRel)
2413 :
2414 : nsDOMSVGPathSegCurvetoQuadraticSmoothRel::nsDOMSVGPathSegCurvetoQuadraticSmoothRel()
2415 : {
2416 : /* member initializers and constructor code */
2417 : }
2418 :
2419 : nsDOMSVGPathSegCurvetoQuadraticSmoothRel::~nsDOMSVGPathSegCurvetoQuadraticSmoothRel()
2420 : {
2421 : /* destructor code */
2422 : }
2423 :
2424 : /* attribute float x; */
2425 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothRel::GetX(float *aX)
2426 : {
2427 : return NS_ERROR_NOT_IMPLEMENTED;
2428 : }
2429 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothRel::SetX(float aX)
2430 : {
2431 : return NS_ERROR_NOT_IMPLEMENTED;
2432 : }
2433 :
2434 : /* attribute float y; */
2435 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothRel::GetY(float *aY)
2436 : {
2437 : return NS_ERROR_NOT_IMPLEMENTED;
2438 : }
2439 : NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothRel::SetY(float aY)
2440 : {
2441 : return NS_ERROR_NOT_IMPLEMENTED;
2442 : }
2443 :
2444 : /* End of implementation class template. */
2445 : #endif
2446 :
2447 :
2448 : #endif /* __gen_nsIDOMSVGPathSeg_h__ */
|