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 "JSSVGEllipseElement.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 "JSSVGAnimatedLength.h"

    34 #include "JSSVGAnimatedString.h"

    35 #include "JSSVGAnimatedTransformList.h"

    36 #include "JSSVGElement.h"

    37 #include "JSSVGMatrix.h"

    38 #include "JSSVGRect.h"

    39 #include "JSSVGStringList.h"

    40 #include "KURL.h"

    41 #include "SVGElement.h"

    42 #include "SVGEllipseElement.h"

    43 #include "SVGStringList.h"

    44 #include <runtime/Error.h>

    45 #include <runtime/JSString.h>

    46 #include <wtf/GetPtr.h>

    47 

    48 using namespace JSC;

    49 

    50 namespace WebCore {

    51 

    52 ASSERT_CLASS_FITS_IN_CELL(JSSVGEllipseElement);

    53 

    54 /* Hash table */

    55 #if ENABLE(JIT)

    56 #define THUNK_GENERATOR(generator) , generator

    57 #else

    58 #define THUNK_GENERATOR(generator)

    59 #endif

    60 

    61 static const HashTableValue JSSVGEllipseElementTableValues[17] =

    62 {

    63     { "cx", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGEllipseElementCx), (intptr_t)0 THUNK_GENERATOR(0) },

    64     { "cy", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGEllipseElementCy), (intptr_t)0 THUNK_GENERATOR(0) },

    65     { "rx", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGEllipseElementRx), (intptr_t)0 THUNK_GENERATOR(0) },

    66     { "ry", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGEllipseElementRy), (intptr_t)0 THUNK_GENERATOR(0) },

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

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

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

    70     { "xmllang", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGEllipseElementXmllang), (intptr_t)setJSSVGEllipseElementXmllang THUNK_GENERATOR(0) },

    71     { "xmlspace", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGEllipseElementXmlspace), (intptr_t)setJSSVGEllipseElementXmlspace THUNK_GENERATOR(0) },

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

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

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

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

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

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

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

    79     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

    80 };

    81 

    82 #undef THUNK_GENERATOR

    83 static JSC_CONST_HASHTABLE HashTable JSSVGEllipseElementTable = { 36, 31, JSSVGEllipseElementTableValues, 0 };

    84 /* Hash table for constructor */

    85 #if ENABLE(JIT)

    86 #define THUNK_GENERATOR(generator) , generator

    87 #else

    88 #define THUNK_GENERATOR(generator)

    89 #endif

    90 

    91 static const HashTableValue JSSVGEllipseElementConstructorTableValues[1] =

    92 {

    93     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

    94 };

    95 

    96 #undef THUNK_GENERATOR

    97 static JSC_CONST_HASHTABLE HashTable JSSVGEllipseElementConstructorTable = { 1, 0, JSSVGEllipseElementConstructorTableValues, 0 };

    98 class JSSVGEllipseElementConstructor : public DOMConstructorObject {

    99 public:

   100     JSSVGEllipseElementConstructor(JSC::ExecState*, JSDOMGlobalObject*);

   101 

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

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

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

   105     static const JSC::ClassInfo s_info;

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

   107     {

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

   109     }

   110 protected:

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

   112 };

   113 

   114 const ClassInfo JSSVGEllipseElementConstructor::s_info = { "SVGEllipseElementConstructor", 0, &JSSVGEllipseElementConstructorTable, 0 };

   115 

   116 JSSVGEllipseElementConstructor::JSSVGEllipseElementConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)

   117     : DOMConstructorObject(JSSVGEllipseElementConstructor::createStructure(globalObject->objectPrototype()), globalObject)

   118 {

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

   120 }

   121 

   122 bool JSSVGEllipseElementConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   123 {

   124     return getStaticValueSlot<JSSVGEllipseElementConstructor, DOMObject>(exec, &JSSVGEllipseElementConstructorTable, this, propertyName, slot);

   125 }

   126 

   127 bool JSSVGEllipseElementConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   128 {

   129     return getStaticValueDescriptor<JSSVGEllipseElementConstructor, DOMObject>(exec, &JSSVGEllipseElementConstructorTable, this, propertyName, descriptor);

   130 }

   131 

   132 /* Hash table for prototype */

   133 #if ENABLE(JIT)

   134 #define THUNK_GENERATOR(generator) , generator

   135 #else

   136 #define THUNK_GENERATOR(generator)

   137 #endif

   138 

   139 static const HashTableValue JSSVGEllipseElementPrototypeTableValues[7] =

   140 {

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

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

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

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

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

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

   147     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   148 };

   149 

   150 #undef THUNK_GENERATOR

   151 static JSC_CONST_HASHTABLE HashTable JSSVGEllipseElementPrototypeTable = { 17, 15, JSSVGEllipseElementPrototypeTableValues, 0 };

   152 const ClassInfo JSSVGEllipseElementPrototype::s_info = { "SVGEllipseElementPrototype", 0, &JSSVGEllipseElementPrototypeTable, 0 };

   153 

   154 JSObject* JSSVGEllipseElementPrototype::self(ExecState* exec, JSGlobalObject* globalObject)

   155 {

   156     return getDOMPrototype<JSSVGEllipseElement>(exec, globalObject);

   157 }

   158 

   159 bool JSSVGEllipseElementPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   160 {

   161     return getStaticFunctionSlot<JSObject>(exec, &JSSVGEllipseElementPrototypeTable, this, propertyName, slot);

   162 }

   163 

   164 bool JSSVGEllipseElementPrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   165 {

   166     return getStaticFunctionDescriptor<JSObject>(exec, &JSSVGEllipseElementPrototypeTable, this, propertyName, descriptor);

   167 }

   168 

   169 const ClassInfo JSSVGEllipseElement::s_info = { "SVGEllipseElement", &JSSVGElement::s_info, &JSSVGEllipseElementTable, 0 };

   170 

   171 JSSVGEllipseElement::JSSVGEllipseElement(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<SVGEllipseElement> impl)

   172     : JSSVGElement(structure, globalObject, impl)

   173 {

   174 }

   175 

   176 JSObject* JSSVGEllipseElement::createPrototype(ExecState* exec, JSGlobalObject* globalObject)

   177 {

   178     return new (exec) JSSVGEllipseElementPrototype(globalObject, JSSVGEllipseElementPrototype::createStructure(JSSVGElementPrototype::self(exec, globalObject)));

   179 }

   180 

   181 bool JSSVGEllipseElement::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   182 {

   183     return getStaticValueSlot<JSSVGEllipseElement, Base>(exec, &JSSVGEllipseElementTable, this, propertyName, slot);

   184 }

   185 

   186 bool JSSVGEllipseElement::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   187 {

   188     return getStaticValueDescriptor<JSSVGEllipseElement, Base>(exec, &JSSVGEllipseElementTable, this, propertyName, descriptor);

   189 }

   190 

   191 JSValue jsSVGEllipseElementCx(ExecState* exec, JSValue slotBase, const Identifier&)

   192 {

   193     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   194     UNUSED_PARAM(exec);

   195     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

   196     RefPtr<SVGAnimatedLength> obj = imp->cxAnimated();

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

   198     return result;

   199 }

   200 

   201 JSValue jsSVGEllipseElementCy(ExecState* exec, JSValue slotBase, const Identifier&)

   202 {

   203     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   204     UNUSED_PARAM(exec);

   205     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

   206     RefPtr<SVGAnimatedLength> obj = imp->cyAnimated();

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

   208     return result;

   209 }

   210 

   211 JSValue jsSVGEllipseElementRx(ExecState* exec, JSValue slotBase, const Identifier&)

   212 {

   213     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   214     UNUSED_PARAM(exec);

   215     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

   216     RefPtr<SVGAnimatedLength> obj = imp->rxAnimated();

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

   218     return result;

   219 }

   220 

   221 JSValue jsSVGEllipseElementRy(ExecState* exec, JSValue slotBase, const Identifier&)

   222 {

   223     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   224     UNUSED_PARAM(exec);

   225     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

   226     RefPtr<SVGAnimatedLength> obj = imp->ryAnimated();

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

   228     return result;

   229 }

   230 

   231 JSValue jsSVGEllipseElementRequiredFeatures(ExecState* exec, JSValue slotBase, const Identifier&)

   232 {

   233     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   234     UNUSED_PARAM(exec);

   235     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   237     return result;

   238 }

   239 

   240 JSValue jsSVGEllipseElementRequiredExtensions(ExecState* exec, JSValue slotBase, const Identifier&)

   241 {

   242     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   243     UNUSED_PARAM(exec);

   244     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   246     return result;

   247 }

   248 

   249 JSValue jsSVGEllipseElementSystemLanguage(ExecState* exec, JSValue slotBase, const Identifier&)

   250 {

   251     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   252     UNUSED_PARAM(exec);

   253     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   255     return result;

   256 }

   257 

   258 JSValue jsSVGEllipseElementXmllang(ExecState* exec, JSValue slotBase, const Identifier&)

   259 {

   260     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   261     UNUSED_PARAM(exec);

   262     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   264     return result;

   265 }

   266 

   267 JSValue jsSVGEllipseElementXmlspace(ExecState* exec, JSValue slotBase, const Identifier&)

   268 {

   269     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   270     UNUSED_PARAM(exec);

   271     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   273     return result;

   274 }

   275 

   276 JSValue jsSVGEllipseElementExternalResourcesRequired(ExecState* exec, JSValue slotBase, const Identifier&)

   277 {

   278     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   279     UNUSED_PARAM(exec);

   280     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

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

   283     return result;

   284 }

   285 

   286 JSValue jsSVGEllipseElementClassName(ExecState* exec, JSValue slotBase, const Identifier&)

   287 {

   288     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   289     UNUSED_PARAM(exec);

   290     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

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

   293     return result;

   294 }

   295 

   296 JSValue jsSVGEllipseElementStyle(ExecState* exec, JSValue slotBase, const Identifier&)

   297 {

   298     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   299     UNUSED_PARAM(exec);

   300     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   302     return result;

   303 }

   304 

   305 JSValue jsSVGEllipseElementTransform(ExecState* exec, JSValue slotBase, const Identifier&)

   306 {

   307     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   308     UNUSED_PARAM(exec);

   309     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

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

   312     return result;

   313 }

   314 

   315 JSValue jsSVGEllipseElementNearestViewportElement(ExecState* exec, JSValue slotBase, const Identifier&)

   316 {

   317     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   318     UNUSED_PARAM(exec);

   319     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   321     return result;

   322 }

   323 

   324 JSValue jsSVGEllipseElementFarthestViewportElement(ExecState* exec, JSValue slotBase, const Identifier&)

   325 {

   326     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   327     UNUSED_PARAM(exec);

   328     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   330     return result;

   331 }

   332 

   333 JSValue jsSVGEllipseElementConstructor(ExecState* exec, JSValue slotBase, const Identifier&)

   334 {

   335     JSSVGEllipseElement* domObject = static_cast<JSSVGEllipseElement*>(asObject(slotBase));

   336     return JSSVGEllipseElement::getConstructor(exec, domObject->globalObject());

   337 }

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

   339 {

   340     lookupPut<JSSVGEllipseElement, Base>(exec, propertyName, value, &JSSVGEllipseElementTable, this, slot);

   341 }

   342 

   343 void setJSSVGEllipseElementXmllang(ExecState* exec, JSObject* thisObject, JSValue value)

   344 {

   345     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(thisObject);

   346     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   348 }

   349 

   350 void setJSSVGEllipseElementXmlspace(ExecState* exec, JSObject* thisObject, JSValue value)

   351 {

   352     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(thisObject);

   353     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   355 }

   356 

   357 JSValue JSSVGEllipseElement::getConstructor(ExecState* exec, JSGlobalObject* globalObject)

   358 {

   359     return getDOMConstructor<JSSVGEllipseElementConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));

   360 }

   361 

   362 EncodedJSValue JSC_HOST_CALL jsSVGEllipseElementPrototypeFunctionHasExtension(ExecState* exec)

   363 {

   364     JSValue thisValue = exec->hostThisValue();

   365     if (!thisValue.inherits(&JSSVGEllipseElement::s_info))

   366         return throwVMTypeError(exec);

   367     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(thisValue));

   368     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   370 

   371 

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

   373     return JSValue::encode(result);

   374 }

   375 

   376 EncodedJSValue JSC_HOST_CALL jsSVGEllipseElementPrototypeFunctionGetPresentationAttribute(ExecState* exec)

   377 {

   378     JSValue thisValue = exec->hostThisValue();

   379     if (!thisValue.inherits(&JSSVGEllipseElement::s_info))

   380         return throwVMTypeError(exec);

   381     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(thisValue));

   382     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

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

   384 

   385 

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

   387     return JSValue::encode(result);

   388 }

   389 

   390 EncodedJSValue JSC_HOST_CALL jsSVGEllipseElementPrototypeFunctionGetBBox(ExecState* exec)

   391 {

   392     JSValue thisValue = exec->hostThisValue();

   393     if (!thisValue.inherits(&JSSVGEllipseElement::s_info))

   394         return throwVMTypeError(exec);

   395     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(thisValue));

   396     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

   397 

   398 

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

   400     return JSValue::encode(result);

   401 }

   402 

   403 EncodedJSValue JSC_HOST_CALL jsSVGEllipseElementPrototypeFunctionGetCTM(ExecState* exec)

   404 {

   405     JSValue thisValue = exec->hostThisValue();

   406     if (!thisValue.inherits(&JSSVGEllipseElement::s_info))

   407         return throwVMTypeError(exec);

   408     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(thisValue));

   409     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

   410 

   411 

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

   413     return JSValue::encode(result);

   414 }

   415 

   416 EncodedJSValue JSC_HOST_CALL jsSVGEllipseElementPrototypeFunctionGetScreenCTM(ExecState* exec)

   417 {

   418     JSValue thisValue = exec->hostThisValue();

   419     if (!thisValue.inherits(&JSSVGEllipseElement::s_info))

   420         return throwVMTypeError(exec);

   421     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(thisValue));

   422     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

   423 

   424 

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

   426     return JSValue::encode(result);

   427 }

   428 

   429 EncodedJSValue JSC_HOST_CALL jsSVGEllipseElementPrototypeFunctionGetTransformToElement(ExecState* exec)

   430 {

   431     JSValue thisValue = exec->hostThisValue();

   432     if (!thisValue.inherits(&JSSVGEllipseElement::s_info))

   433         return throwVMTypeError(exec);

   434     JSSVGEllipseElement* castedThis = static_cast<JSSVGEllipseElement*>(asObject(thisValue));

   435     SVGEllipseElement* imp = static_cast<SVGEllipseElement*>(castedThis->impl());

   436     ExceptionCode ec = 0;

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

   438 

   439 

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

   441     setDOMException(exec, ec);

   442     return JSValue::encode(result);

   443 }

   444 

   445 

   446 }

   447 

   448 #endif // ENABLE(SVG)