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 #include "JSHTMLAppletElement.h"

    23 

    24 #include "HTMLAppletElement.h"

    25 #include "HTMLNames.h"

    26 #include "JSHTMLAppletElementCustom.h"

    27 #include "KURL.h"

    28 #include <runtime/JSString.h>

    29 #include <wtf/GetPtr.h>

    30 

    31 using namespace JSC;

    32 

    33 namespace WebCore {

    34 

    35 ASSERT_CLASS_FITS_IN_CELL(JSHTMLAppletElement);

    36 

    37 /* Hash table */

    38 #if ENABLE(JIT)

    39 #define THUNK_GENERATOR(generator) , generator

    40 #else

    41 #define THUNK_GENERATOR(generator)

    42 #endif

    43 

    44 static const HashTableValue JSHTMLAppletElementTableValues[13] =

    45 {

    46     { "align", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementAlign), (intptr_t)setJSHTMLAppletElementAlign THUNK_GENERATOR(0) },

    47     { "alt", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementAlt), (intptr_t)setJSHTMLAppletElementAlt THUNK_GENERATOR(0) },

    48     { "archive", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementArchive), (intptr_t)setJSHTMLAppletElementArchive THUNK_GENERATOR(0) },

    49     { "code", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementCode), (intptr_t)setJSHTMLAppletElementCode THUNK_GENERATOR(0) },

    50     { "codeBase", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementCodeBase), (intptr_t)setJSHTMLAppletElementCodeBase THUNK_GENERATOR(0) },

    51     { "height", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementHeight), (intptr_t)setJSHTMLAppletElementHeight THUNK_GENERATOR(0) },

    52     { "hspace", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementHspace), (intptr_t)setJSHTMLAppletElementHspace THUNK_GENERATOR(0) },

    53     { "name", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementName), (intptr_t)setJSHTMLAppletElementName THUNK_GENERATOR(0) },

    54     { "object", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementObject), (intptr_t)setJSHTMLAppletElementObject THUNK_GENERATOR(0) },

    55     { "vspace", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementVspace), (intptr_t)setJSHTMLAppletElementVspace THUNK_GENERATOR(0) },

    56     { "width", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLAppletElementWidth), (intptr_t)setJSHTMLAppletElementWidth THUNK_GENERATOR(0) },

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

    58     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

    59 };

    60 

    61 #undef THUNK_GENERATOR

    62 static JSC_CONST_HASHTABLE HashTable JSHTMLAppletElementTable = { 35, 31, JSHTMLAppletElementTableValues, 0 };

    63 /* Hash table for constructor */

    64 #if ENABLE(JIT)

    65 #define THUNK_GENERATOR(generator) , generator

    66 #else

    67 #define THUNK_GENERATOR(generator)

    68 #endif

    69 

    70 static const HashTableValue JSHTMLAppletElementConstructorTableValues[1] =

    71 {

    72     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

    73 };

    74 

    75 #undef THUNK_GENERATOR

    76 static JSC_CONST_HASHTABLE HashTable JSHTMLAppletElementConstructorTable = { 1, 0, JSHTMLAppletElementConstructorTableValues, 0 };

    77 class JSHTMLAppletElementConstructor : public DOMConstructorObject {

    78 public:

    79     JSHTMLAppletElementConstructor(JSC::ExecState*, JSDOMGlobalObject*);

    80 

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

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

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

    84     static const JSC::ClassInfo s_info;

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

    86     {

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

    88     }

    89 protected:

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

    91 };

    92 

    93 const ClassInfo JSHTMLAppletElementConstructor::s_info = { "HTMLAppletElementConstructor", 0, &JSHTMLAppletElementConstructorTable, 0 };

    94 

    95 JSHTMLAppletElementConstructor::JSHTMLAppletElementConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)

    96     : DOMConstructorObject(JSHTMLAppletElementConstructor::createStructure(globalObject->objectPrototype()), globalObject)

    97 {

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

    99 }

   100 

   101 bool JSHTMLAppletElementConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   102 {

   103     return getStaticValueSlot<JSHTMLAppletElementConstructor, DOMObject>(exec, &JSHTMLAppletElementConstructorTable, this, propertyName, slot);

   104 }

   105 

   106 bool JSHTMLAppletElementConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   107 {

   108     return getStaticValueDescriptor<JSHTMLAppletElementConstructor, DOMObject>(exec, &JSHTMLAppletElementConstructorTable, this, propertyName, descriptor);

   109 }

   110 

   111 /* Hash table for prototype */

   112 #if ENABLE(JIT)

   113 #define THUNK_GENERATOR(generator) , generator

   114 #else

   115 #define THUNK_GENERATOR(generator)

   116 #endif

   117 

   118 static const HashTableValue JSHTMLAppletElementPrototypeTableValues[1] =

   119 {

   120     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   121 };

   122 

   123 #undef THUNK_GENERATOR

   124 static JSC_CONST_HASHTABLE HashTable JSHTMLAppletElementPrototypeTable = { 1, 0, JSHTMLAppletElementPrototypeTableValues, 0 };

   125 const ClassInfo JSHTMLAppletElementPrototype::s_info = { "HTMLAppletElementPrototype", 0, &JSHTMLAppletElementPrototypeTable, 0 };

   126 

   127 JSObject* JSHTMLAppletElementPrototype::self(ExecState* exec, JSGlobalObject* globalObject)

   128 {

   129     return getDOMPrototype<JSHTMLAppletElement>(exec, globalObject);

   130 }

   131 

   132 const ClassInfo JSHTMLAppletElement::s_info = { "HTMLAppletElement", &JSHTMLElement::s_info, &JSHTMLAppletElementTable, 0 };

   133 

   134 JSHTMLAppletElement::JSHTMLAppletElement(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<HTMLAppletElement> impl)

   135     : JSHTMLElement(structure, globalObject, impl)

   136 {

   137 }

   138 

   139 JSObject* JSHTMLAppletElement::createPrototype(ExecState* exec, JSGlobalObject* globalObject)

   140 {

   141     return new (exec) JSHTMLAppletElementPrototype(globalObject, JSHTMLAppletElementPrototype::createStructure(JSHTMLElementPrototype::self(exec, globalObject)));

   142 }

   143 

   144 bool JSHTMLAppletElement::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   145 {

   146     if (getOwnPropertySlotDelegate(exec, propertyName, slot))

   147         return true;

   148     return getStaticValueSlot<JSHTMLAppletElement, Base>(exec, &JSHTMLAppletElementTable, this, propertyName, slot);

   149 }

   150 

   151 bool JSHTMLAppletElement::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   152 {

   153     if (getOwnPropertyDescriptorDelegate(exec, propertyName, descriptor))

   154         return true;

   155     return getStaticValueDescriptor<JSHTMLAppletElement, Base>(exec, &JSHTMLAppletElementTable, this, propertyName, descriptor);

   156 }

   157 

   158 JSValue jsHTMLAppletElementAlign(ExecState* exec, JSValue slotBase, const Identifier&)

   159 {

   160     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   161     UNUSED_PARAM(exec);

   162     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   163     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::alignAttr));

   164     return result;

   165 }

   166 

   167 JSValue jsHTMLAppletElementAlt(ExecState* exec, JSValue slotBase, const Identifier&)

   168 {

   169     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   170     UNUSED_PARAM(exec);

   171     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   172     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::altAttr));

   173     return result;

   174 }

   175 

   176 JSValue jsHTMLAppletElementArchive(ExecState* exec, JSValue slotBase, const Identifier&)

   177 {

   178     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   179     UNUSED_PARAM(exec);

   180     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   181     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::archiveAttr));

   182     return result;

   183 }

   184 

   185 JSValue jsHTMLAppletElementCode(ExecState* exec, JSValue slotBase, const Identifier&)

   186 {

   187     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   188     UNUSED_PARAM(exec);

   189     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   190     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::codeAttr));

   191     return result;

   192 }

   193 

   194 JSValue jsHTMLAppletElementCodeBase(ExecState* exec, JSValue slotBase, const Identifier&)

   195 {

   196     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   197     UNUSED_PARAM(exec);

   198     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   199     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::codebaseAttr));

   200     return result;

   201 }

   202 

   203 JSValue jsHTMLAppletElementHeight(ExecState* exec, JSValue slotBase, const Identifier&)

   204 {

   205     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   206     UNUSED_PARAM(exec);

   207     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   208     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::heightAttr));

   209     return result;

   210 }

   211 

   212 JSValue jsHTMLAppletElementHspace(ExecState* exec, JSValue slotBase, const Identifier&)

   213 {

   214     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   215     UNUSED_PARAM(exec);

   216     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   217     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::hspaceAttr));

   218     return result;

   219 }

   220 

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

   222 {

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

   224     UNUSED_PARAM(exec);

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

   226     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::nameAttr));

   227     return result;

   228 }

   229 

   230 JSValue jsHTMLAppletElementObject(ExecState* exec, JSValue slotBase, const Identifier&)

   231 {

   232     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   233     UNUSED_PARAM(exec);

   234     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   235     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::objectAttr));

   236     return result;

   237 }

   238 

   239 JSValue jsHTMLAppletElementVspace(ExecState* exec, JSValue slotBase, const Identifier&)

   240 {

   241     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   242     UNUSED_PARAM(exec);

   243     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   244     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::vspaceAttr));

   245     return result;

   246 }

   247 

   248 JSValue jsHTMLAppletElementWidth(ExecState* exec, JSValue slotBase, const Identifier&)

   249 {

   250     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   251     UNUSED_PARAM(exec);

   252     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   253     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::widthAttr));

   254     return result;

   255 }

   256 

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

   258 {

   259     JSHTMLAppletElement* domObject = static_cast<JSHTMLAppletElement*>(asObject(slotBase));

   260     return JSHTMLAppletElement::getConstructor(exec, domObject->globalObject());

   261 }

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

   263 {

   264     if (putDelegate(exec, propertyName, value, slot))

   265         return;

   266     lookupPut<JSHTMLAppletElement, Base>(exec, propertyName, value, &JSHTMLAppletElementTable, this, slot);

   267 }

   268 

   269 void setJSHTMLAppletElementAlign(ExecState* exec, JSObject* thisObject, JSValue value)

   270 {

   271     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

   272     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   273     imp->setAttribute(WebCore::HTMLNames::alignAttr, valueToStringWithNullCheck(exec, value));

   274 }

   275 

   276 void setJSHTMLAppletElementAlt(ExecState* exec, JSObject* thisObject, JSValue value)

   277 {

   278     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

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

   280     imp->setAttribute(WebCore::HTMLNames::altAttr, valueToStringWithNullCheck(exec, value));

   281 }

   282 

   283 void setJSHTMLAppletElementArchive(ExecState* exec, JSObject* thisObject, JSValue value)

   284 {

   285     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

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

   287     imp->setAttribute(WebCore::HTMLNames::archiveAttr, valueToStringWithNullCheck(exec, value));

   288 }

   289 

   290 void setJSHTMLAppletElementCode(ExecState* exec, JSObject* thisObject, JSValue value)

   291 {

   292     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

   293     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   294     imp->setAttribute(WebCore::HTMLNames::codeAttr, valueToStringWithNullCheck(exec, value));

   295 }

   296 

   297 void setJSHTMLAppletElementCodeBase(ExecState* exec, JSObject* thisObject, JSValue value)

   298 {

   299     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

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

   301     imp->setAttribute(WebCore::HTMLNames::codebaseAttr, valueToStringWithNullCheck(exec, value));

   302 }

   303 

   304 void setJSHTMLAppletElementHeight(ExecState* exec, JSObject* thisObject, JSValue value)

   305 {

   306     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

   307     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   308     imp->setAttribute(WebCore::HTMLNames::heightAttr, valueToStringWithNullCheck(exec, value));

   309 }

   310 

   311 void setJSHTMLAppletElementHspace(ExecState* exec, JSObject* thisObject, JSValue value)

   312 {

   313     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

   314     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   315     imp->setAttribute(WebCore::HTMLNames::hspaceAttr, valueToStringWithNullCheck(exec, value));

   316 }

   317 

   318 void setJSHTMLAppletElementName(ExecState* exec, JSObject* thisObject, JSValue value)

   319 {

   320     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

   321     HTMLAppletElement* imp = static_cast<HTMLAppletElement*>(castedThis->impl());

   322     imp->setAttribute(WebCore::HTMLNames::nameAttr, valueToStringWithNullCheck(exec, value));

   323 }

   324 

   325 void setJSHTMLAppletElementObject(ExecState* exec, JSObject* thisObject, JSValue value)

   326 {

   327     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

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

   329     imp->setAttribute(WebCore::HTMLNames::objectAttr, valueToStringWithNullCheck(exec, value));

   330 }

   331 

   332 void setJSHTMLAppletElementVspace(ExecState* exec, JSObject* thisObject, JSValue value)

   333 {

   334     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

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

   336     imp->setAttribute(WebCore::HTMLNames::vspaceAttr, valueToStringWithNullCheck(exec, value));

   337 }

   338 

   339 void setJSHTMLAppletElementWidth(ExecState* exec, JSObject* thisObject, JSValue value)

   340 {

   341     JSHTMLAppletElement* castedThis = static_cast<JSHTMLAppletElement*>(thisObject);

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

   343     imp->setAttribute(WebCore::HTMLNames::widthAttr, valueToStringWithNullCheck(exec, value));

   344 }

   345 

   346 JSValue JSHTMLAppletElement::getConstructor(ExecState* exec, JSGlobalObject* globalObject)

   347 {

   348     return getDOMConstructor<JSHTMLAppletElementConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));

   349 }

   350 

   351 

   352 }