LCOV - code coverage report
Current view: directory - objdir/dist/include - nsIDOMSVGPathSeg.h (source / functions) Found Hit Coverage
Test: app.info Lines: 20 0 0.0 %
Date: 2012-06-02 Functions: 20 0 0.0 %

       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__ */

Generated by: LCOV version 1.7