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 "JSSVGUseElement.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 "JSSVGElementInstance.h"

    38 #include "JSSVGMatrix.h"

    39 #include "JSSVGRect.h"

    40 #include "JSSVGStringList.h"

    41 #include "KURL.h"

    42 #include "SVGElement.h"

    43 #include "SVGElementInstance.h"

    44 #include "SVGStringList.h"

    45 #include "SVGUseElement.h"

    46 #include <runtime/Error.h>

    47 #include <runtime/JSString.h>

    48 #include <wtf/GetPtr.h>

    49 

    50 using namespace JSC;

    51 

    52 namespace WebCore {

    53 

    54 ASSERT_CLASS_FITS_IN_CELL(JSSVGUseElement);

    55 

    56 /* Hash table */

    57 #if ENABLE(JIT)

    58 #define THUNK_GENERATOR(generator) , generator

    59 #else

    60 #define THUNK_GENERATOR(generator)

    61 #endif

    62 

    63 static const HashTableValue JSSVGUseElementTableValues[20] =

    64 {

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

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

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

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

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

    70     { "animatedInstanceRoot", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGUseElementAnimatedInstanceRoot), (intptr_t)0 THUNK_GENERATOR(0) },

    71     { "href", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGUseElementHref), (intptr_t)0 THUNK_GENERATOR(0) },

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

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

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

    75     { "xmllang", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGUseElementXmllang), (intptr_t)setJSSVGUseElementXmllang THUNK_GENERATOR(0) },

    76     { "xmlspace", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGUseElementXmlspace), (intptr_t)setJSSVGUseElementXmlspace THUNK_GENERATOR(0) },

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

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

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

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

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

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

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

    84     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

    85 };

    86 

    87 #undef THUNK_GENERATOR

    88 static JSC_CONST_HASHTABLE HashTable JSSVGUseElementTable = { 68, 63, JSSVGUseElementTableValues, 0 };

    89 /* Hash table for constructor */

    90 #if ENABLE(JIT)

    91 #define THUNK_GENERATOR(generator) , generator

    92 #else

    93 #define THUNK_GENERATOR(generator)

    94 #endif

    95 

    96 static const HashTableValue JSSVGUseElementConstructorTableValues[1] =

    97 {

    98     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

    99 };

   100 

   101 #undef THUNK_GENERATOR

   102 static JSC_CONST_HASHTABLE HashTable JSSVGUseElementConstructorTable = { 1, 0, JSSVGUseElementConstructorTableValues, 0 };

   103 class JSSVGUseElementConstructor : public DOMConstructorObject {

   104 public:

   105     JSSVGUseElementConstructor(JSC::ExecState*, JSDOMGlobalObject*);

   106 

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

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

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

   110     static const JSC::ClassInfo s_info;

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

   112     {

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

   114     }

   115 protected:

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

   117 };

   118 

   119 const ClassInfo JSSVGUseElementConstructor::s_info = { "SVGUseElementConstructor", 0, &JSSVGUseElementConstructorTable, 0 };

   120 

   121 JSSVGUseElementConstructor::JSSVGUseElementConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)

   122     : DOMConstructorObject(JSSVGUseElementConstructor::createStructure(globalObject->objectPrototype()), globalObject)

   123 {

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

   125 }

   126 

   127 bool JSSVGUseElementConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   128 {

   129     return getStaticValueSlot<JSSVGUseElementConstructor, DOMObject>(exec, &JSSVGUseElementConstructorTable, this, propertyName, slot);

   130 }

   131 

   132 bool JSSVGUseElementConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   133 {

   134     return getStaticValueDescriptor<JSSVGUseElementConstructor, DOMObject>(exec, &JSSVGUseElementConstructorTable, this, propertyName, descriptor);

   135 }

   136 

   137 /* Hash table for prototype */

   138 #if ENABLE(JIT)

   139 #define THUNK_GENERATOR(generator) , generator

   140 #else

   141 #define THUNK_GENERATOR(generator)

   142 #endif

   143 

   144 static const HashTableValue JSSVGUseElementPrototypeTableValues[7] =

   145 {

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

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

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

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

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

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

   152     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   153 };

   154 

   155 #undef THUNK_GENERATOR

   156 static JSC_CONST_HASHTABLE HashTable JSSVGUseElementPrototypeTable = { 17, 15, JSSVGUseElementPrototypeTableValues, 0 };

   157 const ClassInfo JSSVGUseElementPrototype::s_info = { "SVGUseElementPrototype", 0, &JSSVGUseElementPrototypeTable, 0 };

   158 

   159 JSObject* JSSVGUseElementPrototype::self(ExecState* exec, JSGlobalObject* globalObject)

   160 {

   161     return getDOMPrototype<JSSVGUseElement>(exec, globalObject);

   162 }

   163 

   164 bool JSSVGUseElementPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   165 {

   166     return getStaticFunctionSlot<JSObject>(exec, &JSSVGUseElementPrototypeTable, this, propertyName, slot);

   167 }

   168 

   169 bool JSSVGUseElementPrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   170 {

   171     return getStaticFunctionDescriptor<JSObject>(exec, &JSSVGUseElementPrototypeTable, this, propertyName, descriptor);

   172 }

   173 

   174 const ClassInfo JSSVGUseElement::s_info = { "SVGUseElement", &JSSVGElement::s_info, &JSSVGUseElementTable, 0 };

   175 

   176 JSSVGUseElement::JSSVGUseElement(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<SVGUseElement> impl)

   177     : JSSVGElement(structure, globalObject, impl)

   178 {

   179 }

   180 

   181 JSObject* JSSVGUseElement::createPrototype(ExecState* exec, JSGlobalObject* globalObject)

   182 {

   183     return new (exec) JSSVGUseElementPrototype(globalObject, JSSVGUseElementPrototype::createStructure(JSSVGElementPrototype::self(exec, globalObject)));

   184 }

   185 

   186 bool JSSVGUseElement::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   187 {

   188     return getStaticValueSlot<JSSVGUseElement, Base>(exec, &JSSVGUseElementTable, this, propertyName, slot);

   189 }

   190 

   191 bool JSSVGUseElement::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   192 {

   193     return getStaticValueDescriptor<JSSVGUseElement, Base>(exec, &JSSVGUseElementTable, this, propertyName, descriptor);

   194 }

   195 

   196 JSValue jsSVGUseElementX(ExecState* exec, JSValue slotBase, const Identifier&)

   197 {

   198     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   199     UNUSED_PARAM(exec);

   200     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

   201     RefPtr<SVGAnimatedLength> obj = imp->xAnimated();

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

   203     return result;

   204 }

   205 

   206 JSValue jsSVGUseElementY(ExecState* exec, JSValue slotBase, const Identifier&)

   207 {

   208     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   209     UNUSED_PARAM(exec);

   210     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

   211     RefPtr<SVGAnimatedLength> obj = imp->yAnimated();

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

   213     return result;

   214 }

   215 

   216 JSValue jsSVGUseElementWidth(ExecState* exec, JSValue slotBase, const Identifier&)

   217 {

   218     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   219     UNUSED_PARAM(exec);

   220     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

   221     RefPtr<SVGAnimatedLength> obj = imp->widthAnimated();

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

   223     return result;

   224 }

   225 

   226 JSValue jsSVGUseElementHeight(ExecState* exec, JSValue slotBase, const Identifier&)

   227 {

   228     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   229     UNUSED_PARAM(exec);

   230     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

   231     RefPtr<SVGAnimatedLength> obj = imp->heightAnimated();

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

   233     return result;

   234 }

   235 

   236 JSValue jsSVGUseElementInstanceRoot(ExecState* exec, JSValue slotBase, const Identifier&)

   237 {

   238     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   239     UNUSED_PARAM(exec);

   240     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   242     return result;

   243 }

   244 

   245 JSValue jsSVGUseElementAnimatedInstanceRoot(ExecState* exec, JSValue slotBase, const Identifier&)

   246 {

   247     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   248     UNUSED_PARAM(exec);

   249     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   251     return result;

   252 }

   253 

   254 JSValue jsSVGUseElementHref(ExecState* exec, JSValue slotBase, const Identifier&)

   255 {

   256     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   257     UNUSED_PARAM(exec);

   258     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

   259     RefPtr<SVGAnimatedString> obj = imp->hrefAnimated();

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

   261     return result;

   262 }

   263 

   264 JSValue jsSVGUseElementRequiredFeatures(ExecState* exec, JSValue slotBase, const Identifier&)

   265 {

   266     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   267     UNUSED_PARAM(exec);

   268     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   270     return result;

   271 }

   272 

   273 JSValue jsSVGUseElementRequiredExtensions(ExecState* exec, JSValue slotBase, const Identifier&)

   274 {

   275     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   276     UNUSED_PARAM(exec);

   277     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   279     return result;

   280 }

   281 

   282 JSValue jsSVGUseElementSystemLanguage(ExecState* exec, JSValue slotBase, const Identifier&)

   283 {

   284     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   285     UNUSED_PARAM(exec);

   286     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   288     return result;

   289 }

   290 

   291 JSValue jsSVGUseElementXmllang(ExecState* exec, JSValue slotBase, const Identifier&)

   292 {

   293     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   294     UNUSED_PARAM(exec);

   295     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   297     return result;

   298 }

   299 

   300 JSValue jsSVGUseElementXmlspace(ExecState* exec, JSValue slotBase, const Identifier&)

   301 {

   302     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   303     UNUSED_PARAM(exec);

   304     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   306     return result;

   307 }

   308 

   309 JSValue jsSVGUseElementExternalResourcesRequired(ExecState* exec, JSValue slotBase, const Identifier&)

   310 {

   311     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   312     UNUSED_PARAM(exec);

   313     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

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

   316     return result;

   317 }

   318 

   319 JSValue jsSVGUseElementClassName(ExecState* exec, JSValue slotBase, const Identifier&)

   320 {

   321     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   322     UNUSED_PARAM(exec);

   323     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

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

   326     return result;

   327 }

   328 

   329 JSValue jsSVGUseElementStyle(ExecState* exec, JSValue slotBase, const Identifier&)

   330 {

   331     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   332     UNUSED_PARAM(exec);

   333     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   335     return result;

   336 }

   337 

   338 JSValue jsSVGUseElementTransform(ExecState* exec, JSValue slotBase, const Identifier&)

   339 {

   340     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   341     UNUSED_PARAM(exec);

   342     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

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

   345     return result;

   346 }

   347 

   348 JSValue jsSVGUseElementNearestViewportElement(ExecState* exec, JSValue slotBase, const Identifier&)

   349 {

   350     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   351     UNUSED_PARAM(exec);

   352     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   354     return result;

   355 }

   356 

   357 JSValue jsSVGUseElementFarthestViewportElement(ExecState* exec, JSValue slotBase, const Identifier&)

   358 {

   359     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(slotBase));

   360     UNUSED_PARAM(exec);

   361     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   363     return result;

   364 }

   365 

   366 JSValue jsSVGUseElementConstructor(ExecState* exec, JSValue slotBase, const Identifier&)

   367 {

   368     JSSVGUseElement* domObject = static_cast<JSSVGUseElement*>(asObject(slotBase));

   369     return JSSVGUseElement::getConstructor(exec, domObject->globalObject());

   370 }

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

   372 {

   373     lookupPut<JSSVGUseElement, Base>(exec, propertyName, value, &JSSVGUseElementTable, this, slot);

   374 }

   375 

   376 void setJSSVGUseElementXmllang(ExecState* exec, JSObject* thisObject, JSValue value)

   377 {

   378     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(thisObject);

   379     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   381 }

   382 

   383 void setJSSVGUseElementXmlspace(ExecState* exec, JSObject* thisObject, JSValue value)

   384 {

   385     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(thisObject);

   386     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   388 }

   389 

   390 JSValue JSSVGUseElement::getConstructor(ExecState* exec, JSGlobalObject* globalObject)

   391 {

   392     return getDOMConstructor<JSSVGUseElementConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));

   393 }

   394 

   395 EncodedJSValue JSC_HOST_CALL jsSVGUseElementPrototypeFunctionHasExtension(ExecState* exec)

   396 {

   397     JSValue thisValue = exec->hostThisValue();

   398     if (!thisValue.inherits(&JSSVGUseElement::s_info))

   399         return throwVMTypeError(exec);

   400     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(thisValue));

   401     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

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

   403 

   404 

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

   406     return JSValue::encode(result);

   407 }

   408 

   409 EncodedJSValue JSC_HOST_CALL jsSVGUseElementPrototypeFunctionGetPresentationAttribute(ExecState* exec)

   410 {

   411     JSValue thisValue = exec->hostThisValue();

   412     if (!thisValue.inherits(&JSSVGUseElement::s_info))

   413         return throwVMTypeError(exec);

   414     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(thisValue));

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

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

   417 

   418 

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

   420     return JSValue::encode(result);

   421 }

   422 

   423 EncodedJSValue JSC_HOST_CALL jsSVGUseElementPrototypeFunctionGetBBox(ExecState* exec)

   424 {

   425     JSValue thisValue = exec->hostThisValue();

   426     if (!thisValue.inherits(&JSSVGUseElement::s_info))

   427         return throwVMTypeError(exec);

   428     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(thisValue));

   429     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

   430 

   431 

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

   433     return JSValue::encode(result);

   434 }

   435 

   436 EncodedJSValue JSC_HOST_CALL jsSVGUseElementPrototypeFunctionGetCTM(ExecState* exec)

   437 {

   438     JSValue thisValue = exec->hostThisValue();

   439     if (!thisValue.inherits(&JSSVGUseElement::s_info))

   440         return throwVMTypeError(exec);

   441     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(thisValue));

   442     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

   443 

   444 

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

   446     return JSValue::encode(result);

   447 }

   448 

   449 EncodedJSValue JSC_HOST_CALL jsSVGUseElementPrototypeFunctionGetScreenCTM(ExecState* exec)

   450 {

   451     JSValue thisValue = exec->hostThisValue();

   452     if (!thisValue.inherits(&JSSVGUseElement::s_info))

   453         return throwVMTypeError(exec);

   454     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(thisValue));

   455     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

   456 

   457 

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

   459     return JSValue::encode(result);

   460 }

   461 

   462 EncodedJSValue JSC_HOST_CALL jsSVGUseElementPrototypeFunctionGetTransformToElement(ExecState* exec)

   463 {

   464     JSValue thisValue = exec->hostThisValue();

   465     if (!thisValue.inherits(&JSSVGUseElement::s_info))

   466         return throwVMTypeError(exec);

   467     JSSVGUseElement* castedThis = static_cast<JSSVGUseElement*>(asObject(thisValue));

   468     SVGUseElement* imp = static_cast<SVGUseElement*>(castedThis->impl());

   469     ExceptionCode ec = 0;

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

   471 

   472 

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

   474     setDOMException(exec, ec);

   475     return JSValue::encode(result);

   476 }

   477 

   478 

   479 }

   480 

   481 #endif // ENABLE(SVG)