1 /*

     2     This file is part of the WebKit open source project.

     3     This file has been generated by generate-bindings.pl. DO NOT MODIFY!

     4 

     5     This library is free software; you can redistribute it and/or

     6     modify it under the terms of the GNU Library General Public

     7     License as published by the Free Software Foundation; either

     8     version 2 of the License, or (at your option) any later version.

     9 

    10     This library is distributed in the hope that it will be useful,

    11     but WITHOUT ANY WARRANTY; without even the implied warranty of

    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13     Library General Public License for more details.

    14 

    15     You should have received a copy of the GNU Library General Public License

    16     along with this library; see the file COPYING.LIB.  If not, write to

    17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    18     Boston, MA 02110-1301, USA.

    19 */

    20 

    21 #include "config.h"

    22 

    23 #if ENABLE(SVG)

    24 

    25 #include "JSSVGPathElement.h"

    26 

    27 #include "CSSMutableStyleDeclaration.h"

    28 #include "CSSStyleDeclaration.h"

    29 #include "CSSValue.h"

    30 #include "JSCSSStyleDeclaration.h"

    31 #include "JSCSSValue.h"

    32 #include "JSSVGAnimatedBoolean.h"

    33 #include "JSSVGAnimatedNumber.h"

    34 #include "JSSVGAnimatedString.h"

    35 #include "JSSVGAnimatedTransformList.h"

    36 #include "JSSVGElement.h"

    37 #include "JSSVGMatrix.h"

    38 #include "JSSVGPathSegArcAbs.h"

    39 #include "JSSVGPathSegArcRel.h"

    40 #include "JSSVGPathSegClosePath.h"

    41 #include "JSSVGPathSegCurvetoCubicAbs.h"

    42 #include "JSSVGPathSegCurvetoCubicRel.h"

    43 #include "JSSVGPathSegCurvetoCubicSmoothAbs.h"

    44 #include "JSSVGPathSegCurvetoCubicSmoothRel.h"

    45 #include "JSSVGPathSegCurvetoQuadraticAbs.h"

    46 #include "JSSVGPathSegCurvetoQuadraticRel.h"

    47 #include "JSSVGPathSegCurvetoQuadraticSmoothAbs.h"

    48 #include "JSSVGPathSegCurvetoQuadraticSmoothRel.h"

    49 #include "JSSVGPathSegLinetoAbs.h"

    50 #include "JSSVGPathSegLinetoHorizontalAbs.h"

    51 #include "JSSVGPathSegLinetoHorizontalRel.h"

    52 #include "JSSVGPathSegLinetoRel.h"

    53 #include "JSSVGPathSegLinetoVerticalAbs.h"

    54 #include "JSSVGPathSegLinetoVerticalRel.h"

    55 #include "JSSVGPathSegList.h"

    56 #include "JSSVGPathSegMovetoAbs.h"

    57 #include "JSSVGPathSegMovetoRel.h"

    58 #include "JSSVGPoint.h"

    59 #include "JSSVGRect.h"

    60 #include "JSSVGStringList.h"

    61 #include "KURL.h"

    62 #include "SVGElement.h"

    63 #include "SVGPathElement.h"

    64 #include "SVGPathSegArc.h"

    65 #include "SVGPathSegClosePath.h"

    66 #include "SVGPathSegCurvetoCubic.h"

    67 #include "SVGPathSegCurvetoCubicSmooth.h"

    68 #include "SVGPathSegCurvetoQuadratic.h"

    69 #include "SVGPathSegCurvetoQuadraticSmooth.h"

    70 #include "SVGPathSegLineto.h"

    71 #include "SVGPathSegLinetoHorizontal.h"

    72 #include "SVGPathSegLinetoVertical.h"

    73 #include "SVGPathSegList.h"

    74 #include "SVGPathSegMoveto.h"

    75 #include "SVGStringList.h"

    76 #include <runtime/Error.h>

    77 #include <runtime/JSNumberCell.h>

    78 #include <runtime/JSString.h>

    79 #include <wtf/GetPtr.h>

    80 

    81 using namespace JSC;

    82 

    83 namespace WebCore {

    84 

    85 ASSERT_CLASS_FITS_IN_CELL(JSSVGPathElement);

    86 

    87 /* Hash table */

    88 #if ENABLE(JIT)

    89 #define THUNK_GENERATOR(generator) , generator

    90 #else

    91 #define THUNK_GENERATOR(generator)

    92 #endif

    93 

    94 static const HashTableValue JSSVGPathElementTableValues[18] =

    95 {

    96     { "pathLength", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementPathLength), (intptr_t)0 THUNK_GENERATOR(0) },

    97     { "requiredFeatures", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementRequiredFeatures), (intptr_t)0 THUNK_GENERATOR(0) },

    98     { "requiredExtensions", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementRequiredExtensions), (intptr_t)0 THUNK_GENERATOR(0) },

    99     { "systemLanguage", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementSystemLanguage), (intptr_t)0 THUNK_GENERATOR(0) },

   100     { "xmllang", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementXmllang), (intptr_t)setJSSVGPathElementXmllang THUNK_GENERATOR(0) },

   101     { "xmlspace", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementXmlspace), (intptr_t)setJSSVGPathElementXmlspace THUNK_GENERATOR(0) },

   102     { "externalResourcesRequired", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementExternalResourcesRequired), (intptr_t)0 THUNK_GENERATOR(0) },

   103     { "className", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementClassName), (intptr_t)0 THUNK_GENERATOR(0) },

   104     { "style", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementStyle), (intptr_t)0 THUNK_GENERATOR(0) },

   105     { "transform", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementTransform), (intptr_t)0 THUNK_GENERATOR(0) },

   106     { "nearestViewportElement", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementNearestViewportElement), (intptr_t)0 THUNK_GENERATOR(0) },

   107     { "farthestViewportElement", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementFarthestViewportElement), (intptr_t)0 THUNK_GENERATOR(0) },

   108     { "pathSegList", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementPathSegList), (intptr_t)0 THUNK_GENERATOR(0) },

   109     { "normalizedPathSegList", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementNormalizedPathSegList), (intptr_t)0 THUNK_GENERATOR(0) },

   110     { "animatedPathSegList", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementAnimatedPathSegList), (intptr_t)0 THUNK_GENERATOR(0) },

   111     { "animatedNormalizedPathSegList", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementAnimatedNormalizedPathSegList), (intptr_t)0 THUNK_GENERATOR(0) },

   112     { "constructor", DontEnum | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementConstructor), (intptr_t)0 THUNK_GENERATOR(0) },

   113     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   114 };

   115 

   116 #undef THUNK_GENERATOR

   117 static JSC_CONST_HASHTABLE HashTable JSSVGPathElementTable = { 67, 63, JSSVGPathElementTableValues, 0 };

   118 /* Hash table for constructor */

   119 #if ENABLE(JIT)

   120 #define THUNK_GENERATOR(generator) , generator

   121 #else

   122 #define THUNK_GENERATOR(generator)

   123 #endif

   124 

   125 static const HashTableValue JSSVGPathElementConstructorTableValues[1] =

   126 {

   127     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   128 };

   129 

   130 #undef THUNK_GENERATOR

   131 static JSC_CONST_HASHTABLE HashTable JSSVGPathElementConstructorTable = { 1, 0, JSSVGPathElementConstructorTableValues, 0 };

   132 class JSSVGPathElementConstructor : public DOMConstructorObject {

   133 public:

   134     JSSVGPathElementConstructor(JSC::ExecState*, JSDOMGlobalObject*);

   135 

   136     virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier&, JSC::PropertySlot&);

   137     virtual bool getOwnPropertyDescriptor(JSC::ExecState*, const JSC::Identifier&, JSC::PropertyDescriptor&);

   138     virtual const JSC::ClassInfo* classInfo() const { return &s_info; }

   139     static const JSC::ClassInfo s_info;

   140     static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)

   141     {

   142         return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);

   143     }

   144 protected:

   145     static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::ImplementsHasInstance | DOMConstructorObject::StructureFlags;

   146 };

   147 

   148 const ClassInfo JSSVGPathElementConstructor::s_info = { "SVGPathElementConstructor", 0, &JSSVGPathElementConstructorTable, 0 };

   149 

   150 JSSVGPathElementConstructor::JSSVGPathElementConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)

   151     : DOMConstructorObject(JSSVGPathElementConstructor::createStructure(globalObject->objectPrototype()), globalObject)

   152 {

   153     putDirect(exec->propertyNames().prototype, JSSVGPathElementPrototype::self(exec, globalObject), DontDelete | ReadOnly);

   154 }

   155 

   156 bool JSSVGPathElementConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   157 {

   158     return getStaticValueSlot<JSSVGPathElementConstructor, DOMObject>(exec, &JSSVGPathElementConstructorTable, this, propertyName, slot);

   159 }

   160 

   161 bool JSSVGPathElementConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   162 {

   163     return getStaticValueDescriptor<JSSVGPathElementConstructor, DOMObject>(exec, &JSSVGPathElementConstructorTable, this, propertyName, descriptor);

   164 }

   165 

   166 /* Hash table for prototype */

   167 #if ENABLE(JIT)

   168 #define THUNK_GENERATOR(generator) , generator

   169 #else

   170 #define THUNK_GENERATOR(generator)

   171 #endif

   172 

   173 static const HashTableValue JSSVGPathElementPrototypeTableValues[29] =

   174 {

   175     { "getTotalLength", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionGetTotalLength), (intptr_t)0 THUNK_GENERATOR(0) },

   176     { "getPointAtLength", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionGetPointAtLength), (intptr_t)1 THUNK_GENERATOR(0) },

   177     { "getPathSegAtLength", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionGetPathSegAtLength), (intptr_t)1 THUNK_GENERATOR(0) },

   178     { "createSVGPathSegClosePath", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegClosePath), (intptr_t)0 THUNK_GENERATOR(0) },

   179     { "createSVGPathSegMovetoAbs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoAbs), (intptr_t)2 THUNK_GENERATOR(0) },

   180     { "createSVGPathSegMovetoRel", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoRel), (intptr_t)2 THUNK_GENERATOR(0) },

   181     { "createSVGPathSegLinetoAbs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoAbs), (intptr_t)2 THUNK_GENERATOR(0) },

   182     { "createSVGPathSegLinetoRel", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoRel), (intptr_t)2 THUNK_GENERATOR(0) },

   183     { "createSVGPathSegCurvetoCubicAbs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicAbs), (intptr_t)6 THUNK_GENERATOR(0) },

   184     { "createSVGPathSegCurvetoCubicRel", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicRel), (intptr_t)6 THUNK_GENERATOR(0) },

   185     { "createSVGPathSegCurvetoQuadraticAbs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticAbs), (intptr_t)4 THUNK_GENERATOR(0) },

   186     { "createSVGPathSegCurvetoQuadraticRel", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticRel), (intptr_t)4 THUNK_GENERATOR(0) },

   187     { "createSVGPathSegArcAbs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcAbs), (intptr_t)7 THUNK_GENERATOR(0) },

   188     { "createSVGPathSegArcRel", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcRel), (intptr_t)7 THUNK_GENERATOR(0) },

   189     { "createSVGPathSegLinetoHorizontalAbs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalAbs), (intptr_t)1 THUNK_GENERATOR(0) },

   190     { "createSVGPathSegLinetoHorizontalRel", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalRel), (intptr_t)1 THUNK_GENERATOR(0) },

   191     { "createSVGPathSegLinetoVerticalAbs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalAbs), (intptr_t)1 THUNK_GENERATOR(0) },

   192     { "createSVGPathSegLinetoVerticalRel", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalRel), (intptr_t)1 THUNK_GENERATOR(0) },

   193     { "createSVGPathSegCurvetoCubicSmoothAbs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothAbs), (intptr_t)4 THUNK_GENERATOR(0) },

   194     { "createSVGPathSegCurvetoCubicSmoothRel", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothRel), (intptr_t)4 THUNK_GENERATOR(0) },

   195     { "createSVGPathSegCurvetoQuadraticSmoothAbs", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothAbs), (intptr_t)2 THUNK_GENERATOR(0) },

   196     { "createSVGPathSegCurvetoQuadraticSmoothRel", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothRel), (intptr_t)2 THUNK_GENERATOR(0) },

   197     { "hasExtension", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionHasExtension), (intptr_t)1 THUNK_GENERATOR(0) },

   198     { "getPresentationAttribute", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionGetPresentationAttribute), (intptr_t)1 THUNK_GENERATOR(0) },

   199     { "getBBox", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionGetBBox), (intptr_t)0 THUNK_GENERATOR(0) },

   200     { "getCTM", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionGetCTM), (intptr_t)0 THUNK_GENERATOR(0) },

   201     { "getScreenCTM", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionGetScreenCTM), (intptr_t)0 THUNK_GENERATOR(0) },

   202     { "getTransformToElement", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsSVGPathElementPrototypeFunctionGetTransformToElement), (intptr_t)1 THUNK_GENERATOR(0) },

   203     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   204 };

   205 

   206 #undef THUNK_GENERATOR

   207 static JSC_CONST_HASHTABLE HashTable JSSVGPathElementPrototypeTable = { 69, 63, JSSVGPathElementPrototypeTableValues, 0 };

   208 const ClassInfo JSSVGPathElementPrototype::s_info = { "SVGPathElementPrototype", 0, &JSSVGPathElementPrototypeTable, 0 };

   209 

   210 JSObject* JSSVGPathElementPrototype::self(ExecState* exec, JSGlobalObject* globalObject)

   211 {

   212     return getDOMPrototype<JSSVGPathElement>(exec, globalObject);

   213 }

   214 

   215 bool JSSVGPathElementPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   216 {

   217     return getStaticFunctionSlot<JSObject>(exec, &JSSVGPathElementPrototypeTable, this, propertyName, slot);

   218 }

   219 

   220 bool JSSVGPathElementPrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   221 {

   222     return getStaticFunctionDescriptor<JSObject>(exec, &JSSVGPathElementPrototypeTable, this, propertyName, descriptor);

   223 }

   224 

   225 const ClassInfo JSSVGPathElement::s_info = { "SVGPathElement", &JSSVGElement::s_info, &JSSVGPathElementTable, 0 };

   226 

   227 JSSVGPathElement::JSSVGPathElement(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<SVGPathElement> impl)

   228     : JSSVGElement(structure, globalObject, impl)

   229 {

   230 }

   231 

   232 JSObject* JSSVGPathElement::createPrototype(ExecState* exec, JSGlobalObject* globalObject)

   233 {

   234     return new (exec) JSSVGPathElementPrototype(globalObject, JSSVGPathElementPrototype::createStructure(JSSVGElementPrototype::self(exec, globalObject)));

   235 }

   236 

   237 bool JSSVGPathElement::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   238 {

   239     return getStaticValueSlot<JSSVGPathElement, Base>(exec, &JSSVGPathElementTable, this, propertyName, slot);

   240 }

   241 

   242 bool JSSVGPathElement::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   243 {

   244     return getStaticValueDescriptor<JSSVGPathElement, Base>(exec, &JSSVGPathElementTable, this, propertyName, descriptor);

   245 }

   246 

   247 JSValue jsSVGPathElementPathLength(ExecState* exec, JSValue slotBase, const Identifier&)

   248 {

   249     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   250     UNUSED_PARAM(exec);

   251     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   252     RefPtr<SVGAnimatedNumber> obj = imp->pathLengthAnimated();

   253     JSValue result =  toJS(exec, castedThis->globalObject(), obj.get(), imp);

   254     return result;

   255 }

   256 

   257 JSValue jsSVGPathElementRequiredFeatures(ExecState* exec, JSValue slotBase, const Identifier&)

   258 {

   259     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   260     UNUSED_PARAM(exec);

   261     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   262     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->requiredFeatures()), imp);

   263     return result;

   264 }

   265 

   266 JSValue jsSVGPathElementRequiredExtensions(ExecState* exec, JSValue slotBase, const Identifier&)

   267 {

   268     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   269     UNUSED_PARAM(exec);

   270     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   271     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->requiredExtensions()), imp);

   272     return result;

   273 }

   274 

   275 JSValue jsSVGPathElementSystemLanguage(ExecState* exec, JSValue slotBase, const Identifier&)

   276 {

   277     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   278     UNUSED_PARAM(exec);

   279     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   280     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->systemLanguage()), imp);

   281     return result;

   282 }

   283 

   284 JSValue jsSVGPathElementXmllang(ExecState* exec, JSValue slotBase, const Identifier&)

   285 {

   286     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   287     UNUSED_PARAM(exec);

   288     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   289     JSValue result = jsString(exec, imp->xmllang());

   290     return result;

   291 }

   292 

   293 JSValue jsSVGPathElementXmlspace(ExecState* exec, JSValue slotBase, const Identifier&)

   294 {

   295     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   296     UNUSED_PARAM(exec);

   297     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   298     JSValue result = jsString(exec, imp->xmlspace());

   299     return result;

   300 }

   301 

   302 JSValue jsSVGPathElementExternalResourcesRequired(ExecState* exec, JSValue slotBase, const Identifier&)

   303 {

   304     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   305     UNUSED_PARAM(exec);

   306     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   307     RefPtr<SVGAnimatedBoolean> obj = imp->externalResourcesRequiredAnimated();

   308     JSValue result =  toJS(exec, castedThis->globalObject(), obj.get(), imp);

   309     return result;

   310 }

   311 

   312 JSValue jsSVGPathElementClassName(ExecState* exec, JSValue slotBase, const Identifier&)

   313 {

   314     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   315     UNUSED_PARAM(exec);

   316     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   317     RefPtr<SVGAnimatedString> obj = imp->classNameAnimated();

   318     JSValue result =  toJS(exec, castedThis->globalObject(), obj.get(), imp);

   319     return result;

   320 }

   321 

   322 JSValue jsSVGPathElementStyle(ExecState* exec, JSValue slotBase, const Identifier&)

   323 {

   324     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   325     UNUSED_PARAM(exec);

   326     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   327     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->style()));

   328     return result;

   329 }

   330 

   331 JSValue jsSVGPathElementTransform(ExecState* exec, JSValue slotBase, const Identifier&)

   332 {

   333     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   334     UNUSED_PARAM(exec);

   335     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   336     RefPtr<SVGAnimatedTransformList> obj = imp->transformAnimated();

   337     JSValue result =  toJS(exec, castedThis->globalObject(), obj.get(), imp);

   338     return result;

   339 }

   340 

   341 JSValue jsSVGPathElementNearestViewportElement(ExecState* exec, JSValue slotBase, const Identifier&)

   342 {

   343     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   344     UNUSED_PARAM(exec);

   345     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   346     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->nearestViewportElement()));

   347     return result;

   348 }

   349 

   350 JSValue jsSVGPathElementFarthestViewportElement(ExecState* exec, JSValue slotBase, const Identifier&)

   351 {

   352     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   353     UNUSED_PARAM(exec);

   354     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   355     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->farthestViewportElement()));

   356     return result;

   357 }

   358 

   359 JSValue jsSVGPathElementPathSegList(ExecState* exec, JSValue slotBase, const Identifier&)

   360 {

   361     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   362     UNUSED_PARAM(exec);

   363     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   364     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->pathSegList()), imp);

   365     return result;

   366 }

   367 

   368 JSValue jsSVGPathElementNormalizedPathSegList(ExecState* exec, JSValue slotBase, const Identifier&)

   369 {

   370     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   371     UNUSED_PARAM(exec);

   372     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   373     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->normalizedPathSegList()), imp);

   374     return result;

   375 }

   376 

   377 JSValue jsSVGPathElementAnimatedPathSegList(ExecState* exec, JSValue slotBase, const Identifier&)

   378 {

   379     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   380     UNUSED_PARAM(exec);

   381     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   382     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->animatedPathSegList()), imp);

   383     return result;

   384 }

   385 

   386 JSValue jsSVGPathElementAnimatedNormalizedPathSegList(ExecState* exec, JSValue slotBase, const Identifier&)

   387 {

   388     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(slotBase));

   389     UNUSED_PARAM(exec);

   390     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   391     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->animatedNormalizedPathSegList()), imp);

   392     return result;

   393 }

   394 

   395 JSValue jsSVGPathElementConstructor(ExecState* exec, JSValue slotBase, const Identifier&)

   396 {

   397     JSSVGPathElement* domObject = static_cast<JSSVGPathElement*>(asObject(slotBase));

   398     return JSSVGPathElement::getConstructor(exec, domObject->globalObject());

   399 }

   400 void JSSVGPathElement::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)

   401 {

   402     lookupPut<JSSVGPathElement, Base>(exec, propertyName, value, &JSSVGPathElementTable, this, slot);

   403 }

   404 

   405 void setJSSVGPathElementXmllang(ExecState* exec, JSObject* thisObject, JSValue value)

   406 {

   407     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(thisObject);

   408     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   409     imp->setXmllang(ustringToString(value.toString(exec)));

   410 }

   411 

   412 void setJSSVGPathElementXmlspace(ExecState* exec, JSObject* thisObject, JSValue value)

   413 {

   414     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(thisObject);

   415     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   416     imp->setXmlspace(ustringToString(value.toString(exec)));

   417 }

   418 

   419 JSValue JSSVGPathElement::getConstructor(ExecState* exec, JSGlobalObject* globalObject)

   420 {

   421     return getDOMConstructor<JSSVGPathElementConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));

   422 }

   423 

   424 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionGetTotalLength(ExecState* exec)

   425 {

   426     JSValue thisValue = exec->hostThisValue();

   427     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   428         return throwVMTypeError(exec);

   429     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   430     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   431 

   432 

   433     JSC::JSValue result = jsNumber(exec, imp->getTotalLength());

   434     return JSValue::encode(result);

   435 }

   436 

   437 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionGetPointAtLength(ExecState* exec)

   438 {

   439     JSValue thisValue = exec->hostThisValue();

   440     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   441         return throwVMTypeError(exec);

   442     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   443     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   444     float distance = exec->argument(0).toFloat(exec);

   445 

   446 

   447     JSC::JSValue result = toJS(exec, castedThis->globalObject(), JSSVGStaticPODTypeWrapper<FloatPoint>::create(imp->getPointAtLength(distance)).get(), 0 /* no context on purpose */);

   448     return JSValue::encode(result);

   449 }

   450 

   451 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionGetPathSegAtLength(ExecState* exec)

   452 {

   453     JSValue thisValue = exec->hostThisValue();

   454     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   455         return throwVMTypeError(exec);

   456     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   457     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   458     ExceptionCode ec = 0;

   459     float distance = exec->argument(0).toFloat(exec);

   460 

   461 

   462     JSC::JSValue result = jsNumber(exec, imp->getPathSegAtLength(distance, ec));

   463     setDOMException(exec, ec);

   464     return JSValue::encode(result);

   465 }

   466 

   467 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegClosePath(ExecState* exec)

   468 {

   469     JSValue thisValue = exec->hostThisValue();

   470     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   471         return throwVMTypeError(exec);

   472     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   473     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   474 

   475 

   476     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegClosePath()), imp);

   477     return JSValue::encode(result);

   478 }

   479 

   480 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoAbs(ExecState* exec)

   481 {

   482     JSValue thisValue = exec->hostThisValue();

   483     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   484         return throwVMTypeError(exec);

   485     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   486     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   487     float x = exec->argument(0).toFloat(exec);

   488     float y = exec->argument(1).toFloat(exec);

   489 

   490 

   491     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegMovetoAbs(x, y)), imp);

   492     return JSValue::encode(result);

   493 }

   494 

   495 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoRel(ExecState* exec)

   496 {

   497     JSValue thisValue = exec->hostThisValue();

   498     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   499         return throwVMTypeError(exec);

   500     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   501     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   502     float x = exec->argument(0).toFloat(exec);

   503     float y = exec->argument(1).toFloat(exec);

   504 

   505 

   506     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegMovetoRel(x, y)), imp);

   507     return JSValue::encode(result);

   508 }

   509 

   510 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoAbs(ExecState* exec)

   511 {

   512     JSValue thisValue = exec->hostThisValue();

   513     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   514         return throwVMTypeError(exec);

   515     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   516     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   517     float x = exec->argument(0).toFloat(exec);

   518     float y = exec->argument(1).toFloat(exec);

   519 

   520 

   521     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegLinetoAbs(x, y)), imp);

   522     return JSValue::encode(result);

   523 }

   524 

   525 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoRel(ExecState* exec)

   526 {

   527     JSValue thisValue = exec->hostThisValue();

   528     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   529         return throwVMTypeError(exec);

   530     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   531     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   532     float x = exec->argument(0).toFloat(exec);

   533     float y = exec->argument(1).toFloat(exec);

   534 

   535 

   536     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegLinetoRel(x, y)), imp);

   537     return JSValue::encode(result);

   538 }

   539 

   540 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicAbs(ExecState* exec)

   541 {

   542     JSValue thisValue = exec->hostThisValue();

   543     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   544         return throwVMTypeError(exec);

   545     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   546     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   547     float x = exec->argument(0).toFloat(exec);

   548     float y = exec->argument(1).toFloat(exec);

   549     float x1 = exec->argument(2).toFloat(exec);

   550     float y1 = exec->argument(3).toFloat(exec);

   551     float x2 = exec->argument(4).toFloat(exec);

   552     float y2 = exec->argument(5).toFloat(exec);

   553 

   554 

   555     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegCurvetoCubicAbs(x, y, x1, y1, x2, y2)), imp);

   556     return JSValue::encode(result);

   557 }

   558 

   559 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicRel(ExecState* exec)

   560 {

   561     JSValue thisValue = exec->hostThisValue();

   562     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   563         return throwVMTypeError(exec);

   564     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   565     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   566     float x = exec->argument(0).toFloat(exec);

   567     float y = exec->argument(1).toFloat(exec);

   568     float x1 = exec->argument(2).toFloat(exec);

   569     float y1 = exec->argument(3).toFloat(exec);

   570     float x2 = exec->argument(4).toFloat(exec);

   571     float y2 = exec->argument(5).toFloat(exec);

   572 

   573 

   574     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegCurvetoCubicRel(x, y, x1, y1, x2, y2)), imp);

   575     return JSValue::encode(result);

   576 }

   577 

   578 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticAbs(ExecState* exec)

   579 {

   580     JSValue thisValue = exec->hostThisValue();

   581     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   582         return throwVMTypeError(exec);

   583     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   584     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   585     float x = exec->argument(0).toFloat(exec);

   586     float y = exec->argument(1).toFloat(exec);

   587     float x1 = exec->argument(2).toFloat(exec);

   588     float y1 = exec->argument(3).toFloat(exec);

   589 

   590 

   591     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegCurvetoQuadraticAbs(x, y, x1, y1)), imp);

   592     return JSValue::encode(result);

   593 }

   594 

   595 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticRel(ExecState* exec)

   596 {

   597     JSValue thisValue = exec->hostThisValue();

   598     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   599         return throwVMTypeError(exec);

   600     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   601     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   602     float x = exec->argument(0).toFloat(exec);

   603     float y = exec->argument(1).toFloat(exec);

   604     float x1 = exec->argument(2).toFloat(exec);

   605     float y1 = exec->argument(3).toFloat(exec);

   606 

   607 

   608     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegCurvetoQuadraticRel(x, y, x1, y1)), imp);

   609     return JSValue::encode(result);

   610 }

   611 

   612 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcAbs(ExecState* exec)

   613 {

   614     JSValue thisValue = exec->hostThisValue();

   615     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   616         return throwVMTypeError(exec);

   617     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   618     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   619     float x = exec->argument(0).toFloat(exec);

   620     float y = exec->argument(1).toFloat(exec);

   621     float r1 = exec->argument(2).toFloat(exec);

   622     float r2 = exec->argument(3).toFloat(exec);

   623     float angle = exec->argument(4).toFloat(exec);

   624     bool largeArcFlag = exec->argument(5).toBoolean(exec);

   625     bool sweepFlag = exec->argument(6).toBoolean(exec);

   626 

   627 

   628     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegArcAbs(x, y, r1, r2, angle, largeArcFlag, sweepFlag)), imp);

   629     return JSValue::encode(result);

   630 }

   631 

   632 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcRel(ExecState* exec)

   633 {

   634     JSValue thisValue = exec->hostThisValue();

   635     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   636         return throwVMTypeError(exec);

   637     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   638     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   639     float x = exec->argument(0).toFloat(exec);

   640     float y = exec->argument(1).toFloat(exec);

   641     float r1 = exec->argument(2).toFloat(exec);

   642     float r2 = exec->argument(3).toFloat(exec);

   643     float angle = exec->argument(4).toFloat(exec);

   644     bool largeArcFlag = exec->argument(5).toBoolean(exec);

   645     bool sweepFlag = exec->argument(6).toBoolean(exec);

   646 

   647 

   648     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegArcRel(x, y, r1, r2, angle, largeArcFlag, sweepFlag)), imp);

   649     return JSValue::encode(result);

   650 }

   651 

   652 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalAbs(ExecState* exec)

   653 {

   654     JSValue thisValue = exec->hostThisValue();

   655     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   656         return throwVMTypeError(exec);

   657     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   658     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   659     float x = exec->argument(0).toFloat(exec);

   660 

   661 

   662     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegLinetoHorizontalAbs(x)), imp);

   663     return JSValue::encode(result);

   664 }

   665 

   666 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalRel(ExecState* exec)

   667 {

   668     JSValue thisValue = exec->hostThisValue();

   669     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   670         return throwVMTypeError(exec);

   671     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   672     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   673     float x = exec->argument(0).toFloat(exec);

   674 

   675 

   676     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegLinetoHorizontalRel(x)), imp);

   677     return JSValue::encode(result);

   678 }

   679 

   680 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalAbs(ExecState* exec)

   681 {

   682     JSValue thisValue = exec->hostThisValue();

   683     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   684         return throwVMTypeError(exec);

   685     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   686     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   687     float y = exec->argument(0).toFloat(exec);

   688 

   689 

   690     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegLinetoVerticalAbs(y)), imp);

   691     return JSValue::encode(result);

   692 }

   693 

   694 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalRel(ExecState* exec)

   695 {

   696     JSValue thisValue = exec->hostThisValue();

   697     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   698         return throwVMTypeError(exec);

   699     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   700     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   701     float y = exec->argument(0).toFloat(exec);

   702 

   703 

   704     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegLinetoVerticalRel(y)), imp);

   705     return JSValue::encode(result);

   706 }

   707 

   708 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothAbs(ExecState* exec)

   709 {

   710     JSValue thisValue = exec->hostThisValue();

   711     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   712         return throwVMTypeError(exec);

   713     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   714     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   715     float x = exec->argument(0).toFloat(exec);

   716     float y = exec->argument(1).toFloat(exec);

   717     float x2 = exec->argument(2).toFloat(exec);

   718     float y2 = exec->argument(3).toFloat(exec);

   719 

   720 

   721     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegCurvetoCubicSmoothAbs(x, y, x2, y2)), imp);

   722     return JSValue::encode(result);

   723 }

   724 

   725 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothRel(ExecState* exec)

   726 {

   727     JSValue thisValue = exec->hostThisValue();

   728     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   729         return throwVMTypeError(exec);

   730     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   731     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   732     float x = exec->argument(0).toFloat(exec);

   733     float y = exec->argument(1).toFloat(exec);

   734     float x2 = exec->argument(2).toFloat(exec);

   735     float y2 = exec->argument(3).toFloat(exec);

   736 

   737 

   738     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegCurvetoCubicSmoothRel(x, y, x2, y2)), imp);

   739     return JSValue::encode(result);

   740 }

   741 

   742 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothAbs(ExecState* exec)

   743 {

   744     JSValue thisValue = exec->hostThisValue();

   745     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   746         return throwVMTypeError(exec);

   747     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   748     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   749     float x = exec->argument(0).toFloat(exec);

   750     float y = exec->argument(1).toFloat(exec);

   751 

   752 

   753     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegCurvetoQuadraticSmoothAbs(x, y)), imp);

   754     return JSValue::encode(result);

   755 }

   756 

   757 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothRel(ExecState* exec)

   758 {

   759     JSValue thisValue = exec->hostThisValue();

   760     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   761         return throwVMTypeError(exec);

   762     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   763     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   764     float x = exec->argument(0).toFloat(exec);

   765     float y = exec->argument(1).toFloat(exec);

   766 

   767 

   768     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createSVGPathSegCurvetoQuadraticSmoothRel(x, y)), imp);

   769     return JSValue::encode(result);

   770 }

   771 

   772 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionHasExtension(ExecState* exec)

   773 {

   774     JSValue thisValue = exec->hostThisValue();

   775     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   776         return throwVMTypeError(exec);

   777     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   778     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   779     const String& extension = ustringToString(exec->argument(0).toString(exec));

   780 

   781 

   782     JSC::JSValue result = jsBoolean(imp->hasExtension(extension));

   783     return JSValue::encode(result);

   784 }

   785 

   786 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionGetPresentationAttribute(ExecState* exec)

   787 {

   788     JSValue thisValue = exec->hostThisValue();

   789     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   790         return throwVMTypeError(exec);

   791     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   792     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   793     const String& name = ustringToString(exec->argument(0).toString(exec));

   794 

   795 

   796     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->getPresentationAttribute(name)));

   797     return JSValue::encode(result);

   798 }

   799 

   800 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionGetBBox(ExecState* exec)

   801 {

   802     JSValue thisValue = exec->hostThisValue();

   803     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   804         return throwVMTypeError(exec);

   805     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   806     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   807 

   808 

   809     JSC::JSValue result = toJS(exec, castedThis->globalObject(), JSSVGStaticPODTypeWrapper<FloatRect>::create(imp->getBBox()).get(), 0 /* no context on purpose */);

   810     return JSValue::encode(result);

   811 }

   812 

   813 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionGetCTM(ExecState* exec)

   814 {

   815     JSValue thisValue = exec->hostThisValue();

   816     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   817         return throwVMTypeError(exec);

   818     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   819     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   820 

   821 

   822     JSC::JSValue result = toJS(exec, castedThis->globalObject(), JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp->getCTM()).get(), 0 /* no context on purpose */);

   823     return JSValue::encode(result);

   824 }

   825 

   826 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionGetScreenCTM(ExecState* exec)

   827 {

   828     JSValue thisValue = exec->hostThisValue();

   829     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   830         return throwVMTypeError(exec);

   831     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   832     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   833 

   834 

   835     JSC::JSValue result = toJS(exec, castedThis->globalObject(), JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp->getScreenCTM()).get(), 0 /* no context on purpose */);

   836     return JSValue::encode(result);

   837 }

   838 

   839 EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionGetTransformToElement(ExecState* exec)

   840 {

   841     JSValue thisValue = exec->hostThisValue();

   842     if (!thisValue.inherits(&JSSVGPathElement::s_info))

   843         return throwVMTypeError(exec);

   844     JSSVGPathElement* castedThis = static_cast<JSSVGPathElement*>(asObject(thisValue));

   845     SVGPathElement* imp = static_cast<SVGPathElement*>(castedThis->impl());

   846     ExceptionCode ec = 0;

   847     SVGElement* element = toSVGElement(exec->argument(0));

   848 

   849 

   850     JSC::JSValue result = toJS(exec, castedThis->globalObject(), JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp->getTransformToElement(element, ec)).get(), 0 /* no context on purpose */);

   851     setDOMException(exec, ec);

   852     return JSValue::encode(result);

   853 }

   854 

   855 

   856 }

   857 

   858 #endif // ENABLE(SVG)