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 "JSElement.h"

    23 

    24 #include "Attr.h"

    25 #include "CSSMutableStyleDeclaration.h"

    26 #include "CSSStyleDeclaration.h"

    27 #include "ClientRect.h"

    28 #include "ClientRectList.h"

    29 #include "DOMStringMap.h"

    30 #include "Element.h"

    31 #include "EventListener.h"

    32 #include "JSAttr.h"

    33 #include "JSCSSStyleDeclaration.h"

    34 #include "JSClientRect.h"

    35 #include "JSClientRectList.h"

    36 #include "JSDOMStringMap.h"

    37 #include "JSElement.h"

    38 #include "JSEventListener.h"

    39 #include "JSNodeList.h"

    40 #include "KURL.h"

    41 #include "NameNodeList.h"

    42 #include "NodeList.h"

    43 #include <runtime/Error.h>

    44 #include <runtime/JSNumberCell.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(JSElement);

    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 JSElementTableValues[69] =

    62 {

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

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

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

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

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

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

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

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

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

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

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

    74     { "scrollLeft", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementScrollLeft), (intptr_t)setJSElementScrollLeft THUNK_GENERATOR(0) },

    75     { "scrollTop", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementScrollTop), (intptr_t)setJSElementScrollTop THUNK_GENERATOR(0) },

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

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

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

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

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

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

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

    83     { "childElementCount", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementChildElementCount), (intptr_t)0 THUNK_GENERATOR(0) },

    84     { "onabort", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnabort), (intptr_t)setJSElementOnabort THUNK_GENERATOR(0) },

    85     { "onblur", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnblur), (intptr_t)setJSElementOnblur THUNK_GENERATOR(0) },

    86     { "onchange", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnchange), (intptr_t)setJSElementOnchange THUNK_GENERATOR(0) },

    87     { "onclick", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnclick), (intptr_t)setJSElementOnclick THUNK_GENERATOR(0) },

    88     { "oncontextmenu", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOncontextmenu), (intptr_t)setJSElementOncontextmenu THUNK_GENERATOR(0) },

    89     { "ondblclick", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOndblclick), (intptr_t)setJSElementOndblclick THUNK_GENERATOR(0) },

    90     { "ondrag", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOndrag), (intptr_t)setJSElementOndrag THUNK_GENERATOR(0) },

    91     { "ondragend", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOndragend), (intptr_t)setJSElementOndragend THUNK_GENERATOR(0) },

    92     { "ondragenter", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOndragenter), (intptr_t)setJSElementOndragenter THUNK_GENERATOR(0) },

    93     { "ondragleave", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOndragleave), (intptr_t)setJSElementOndragleave THUNK_GENERATOR(0) },

    94     { "ondragover", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOndragover), (intptr_t)setJSElementOndragover THUNK_GENERATOR(0) },

    95     { "ondragstart", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOndragstart), (intptr_t)setJSElementOndragstart THUNK_GENERATOR(0) },

    96     { "ondrop", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOndrop), (intptr_t)setJSElementOndrop THUNK_GENERATOR(0) },

    97     { "onerror", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnerror), (intptr_t)setJSElementOnerror THUNK_GENERATOR(0) },

    98     { "onfocus", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnfocus), (intptr_t)setJSElementOnfocus THUNK_GENERATOR(0) },

    99     { "oninput", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOninput), (intptr_t)setJSElementOninput THUNK_GENERATOR(0) },

   100     { "oninvalid", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOninvalid), (intptr_t)setJSElementOninvalid THUNK_GENERATOR(0) },

   101     { "onkeydown", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnkeydown), (intptr_t)setJSElementOnkeydown THUNK_GENERATOR(0) },

   102     { "onkeypress", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnkeypress), (intptr_t)setJSElementOnkeypress THUNK_GENERATOR(0) },

   103     { "onkeyup", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnkeyup), (intptr_t)setJSElementOnkeyup THUNK_GENERATOR(0) },

   104     { "onload", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnload), (intptr_t)setJSElementOnload THUNK_GENERATOR(0) },

   105     { "onmousedown", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnmousedown), (intptr_t)setJSElementOnmousedown THUNK_GENERATOR(0) },

   106     { "onmousemove", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnmousemove), (intptr_t)setJSElementOnmousemove THUNK_GENERATOR(0) },

   107     { "onmouseout", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnmouseout), (intptr_t)setJSElementOnmouseout THUNK_GENERATOR(0) },

   108     { "onmouseover", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnmouseover), (intptr_t)setJSElementOnmouseover THUNK_GENERATOR(0) },

   109     { "onmouseup", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnmouseup), (intptr_t)setJSElementOnmouseup THUNK_GENERATOR(0) },

   110     { "onmousewheel", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnmousewheel), (intptr_t)setJSElementOnmousewheel THUNK_GENERATOR(0) },

   111     { "onscroll", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnscroll), (intptr_t)setJSElementOnscroll THUNK_GENERATOR(0) },

   112     { "onselect", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnselect), (intptr_t)setJSElementOnselect THUNK_GENERATOR(0) },

   113     { "onsubmit", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnsubmit), (intptr_t)setJSElementOnsubmit THUNK_GENERATOR(0) },

   114     { "onbeforecut", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnbeforecut), (intptr_t)setJSElementOnbeforecut THUNK_GENERATOR(0) },

   115     { "oncut", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOncut), (intptr_t)setJSElementOncut THUNK_GENERATOR(0) },

   116     { "onbeforecopy", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnbeforecopy), (intptr_t)setJSElementOnbeforecopy THUNK_GENERATOR(0) },

   117     { "oncopy", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOncopy), (intptr_t)setJSElementOncopy THUNK_GENERATOR(0) },

   118     { "onbeforepaste", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnbeforepaste), (intptr_t)setJSElementOnbeforepaste THUNK_GENERATOR(0) },

   119     { "onpaste", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnpaste), (intptr_t)setJSElementOnpaste THUNK_GENERATOR(0) },

   120     { "onreset", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnreset), (intptr_t)setJSElementOnreset THUNK_GENERATOR(0) },

   121     { "onsearch", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnsearch), (intptr_t)setJSElementOnsearch THUNK_GENERATOR(0) },

   122     { "onselectstart", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOnselectstart), (intptr_t)setJSElementOnselectstart THUNK_GENERATOR(0) },

   123 #if ENABLE(TOUCH_EVENTS)

   124     { "ontouchstart", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOntouchstart), (intptr_t)setJSElementOntouchstart THUNK_GENERATOR(0) },

   125 #endif

   126 #if ENABLE(TOUCH_EVENTS)

   127     { "ontouchmove", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOntouchmove), (intptr_t)setJSElementOntouchmove THUNK_GENERATOR(0) },

   128 #endif

   129 #if ENABLE(TOUCH_EVENTS)

   130     { "ontouchend", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOntouchend), (intptr_t)setJSElementOntouchend THUNK_GENERATOR(0) },

   131 #endif

   132 #if ENABLE(TOUCH_EVENTS)

   133     { "ontouchcancel", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOntouchcancel), (intptr_t)setJSElementOntouchcancel THUNK_GENERATOR(0) },

   134 #endif

   135 #if ENABLE(TRANSFORMACTION_EVENTS)

   136     { "ontransformactionstart", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOntransformactionstart), (intptr_t)setJSElementOntransformactionstart THUNK_GENERATOR(0) },

   137 #endif

   138 #if ENABLE(TRANSFORMACTION_EVENTS)

   139     { "ontransformactionupdate", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOntransformactionupdate), (intptr_t)setJSElementOntransformactionupdate THUNK_GENERATOR(0) },

   140 #endif

   141 #if ENABLE(TRANSFORMACTION_EVENTS)

   142     { "ontransformactionend", DontDelete | DontEnum, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsElementOntransformactionend), (intptr_t)setJSElementOntransformactionend THUNK_GENERATOR(0) },

   143 #endif

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

   145     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   146 };

   147 

   148 #undef THUNK_GENERATOR

   149 static JSC_CONST_HASHTABLE HashTable JSElementTable = { 264, 255, JSElementTableValues, 0 };

   150 /* Hash table for constructor */

   151 #if ENABLE(JIT)

   152 #define THUNK_GENERATOR(generator) , generator

   153 #else

   154 #define THUNK_GENERATOR(generator)

   155 #endif

   156 

   157 static const HashTableValue JSElementConstructorTableValues[1] =

   158 {

   159     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   160 };

   161 

   162 #undef THUNK_GENERATOR

   163 static JSC_CONST_HASHTABLE HashTable JSElementConstructorTable = { 1, 0, JSElementConstructorTableValues, 0 };

   164 class JSElementConstructor : public DOMConstructorObject {

   165 public:

   166     JSElementConstructor(JSC::ExecState*, JSDOMGlobalObject*);

   167 

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

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

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

   171     static const JSC::ClassInfo s_info;

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

   173     {

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

   175     }

   176 protected:

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

   178 };

   179 

   180 const ClassInfo JSElementConstructor::s_info = { "ElementConstructor", 0, &JSElementConstructorTable, 0 };

   181 

   182 JSElementConstructor::JSElementConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)

   183     : DOMConstructorObject(JSElementConstructor::createStructure(globalObject->objectPrototype()), globalObject)

   184 {

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

   186 }

   187 

   188 bool JSElementConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   189 {

   190     return getStaticValueSlot<JSElementConstructor, DOMObject>(exec, &JSElementConstructorTable, this, propertyName, slot);

   191 }

   192 

   193 bool JSElementConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   194 {

   195     return getStaticValueDescriptor<JSElementConstructor, DOMObject>(exec, &JSElementConstructorTable, this, propertyName, descriptor);

   196 }

   197 

   198 /* Hash table for prototype */

   199 #if ENABLE(JIT)

   200 #define THUNK_GENERATOR(generator) , generator

   201 #else

   202 #define THUNK_GENERATOR(generator)

   203 #endif

   204 

   205 static const HashTableValue JSElementPrototypeTableValues[29] =

   206 {

   207     { "getAttribute", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionGetAttribute), (intptr_t)1 THUNK_GENERATOR(0) },

   208     { "setAttribute", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionSetAttribute), (intptr_t)2 THUNK_GENERATOR(0) },

   209     { "removeAttribute", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionRemoveAttribute), (intptr_t)1 THUNK_GENERATOR(0) },

   210     { "getAttributeNode", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionGetAttributeNode), (intptr_t)1 THUNK_GENERATOR(0) },

   211     { "setAttributeNode", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionSetAttributeNode), (intptr_t)1 THUNK_GENERATOR(0) },

   212     { "removeAttributeNode", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionRemoveAttributeNode), (intptr_t)1 THUNK_GENERATOR(0) },

   213     { "getElementsByTagName", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionGetElementsByTagName), (intptr_t)1 THUNK_GENERATOR(0) },

   214     { "getAttributeNS", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionGetAttributeNS), (intptr_t)2 THUNK_GENERATOR(0) },

   215     { "setAttributeNS", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionSetAttributeNS), (intptr_t)3 THUNK_GENERATOR(0) },

   216     { "removeAttributeNS", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionRemoveAttributeNS), (intptr_t)2 THUNK_GENERATOR(0) },

   217     { "getElementsByTagNameNS", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionGetElementsByTagNameNS), (intptr_t)2 THUNK_GENERATOR(0) },

   218     { "getAttributeNodeNS", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionGetAttributeNodeNS), (intptr_t)2 THUNK_GENERATOR(0) },

   219     { "setAttributeNodeNS", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionSetAttributeNodeNS), (intptr_t)1 THUNK_GENERATOR(0) },

   220     { "hasAttribute", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionHasAttribute), (intptr_t)1 THUNK_GENERATOR(0) },

   221     { "hasAttributeNS", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionHasAttributeNS), (intptr_t)2 THUNK_GENERATOR(0) },

   222     { "focus", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionFocus), (intptr_t)0 THUNK_GENERATOR(0) },

   223     { "blur", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionBlur), (intptr_t)0 THUNK_GENERATOR(0) },

   224     { "scrollIntoView", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionScrollIntoView), (intptr_t)1 THUNK_GENERATOR(0) },

   225     { "contains", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionContains), (intptr_t)1 THUNK_GENERATOR(0) },

   226     { "scrollIntoViewIfNeeded", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionScrollIntoViewIfNeeded), (intptr_t)1 THUNK_GENERATOR(0) },

   227     { "scrollByLines", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionScrollByLines), (intptr_t)1 THUNK_GENERATOR(0) },

   228     { "scrollByPages", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionScrollByPages), (intptr_t)1 THUNK_GENERATOR(0) },

   229     { "getElementsByClassName", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionGetElementsByClassName), (intptr_t)1 THUNK_GENERATOR(0) },

   230     { "querySelector", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionQuerySelector), (intptr_t)1 THUNK_GENERATOR(0) },

   231     { "querySelectorAll", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionQuerySelectorAll), (intptr_t)1 THUNK_GENERATOR(0) },

   232     { "webkitMatchesSelector", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionWebkitMatchesSelector), (intptr_t)1 THUNK_GENERATOR(0) },

   233     { "getClientRects", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionGetClientRects), (intptr_t)0 THUNK_GENERATOR(0) },

   234     { "getBoundingClientRect", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsElementPrototypeFunctionGetBoundingClientRect), (intptr_t)0 THUNK_GENERATOR(0) },

   235     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   236 };

   237 

   238 #undef THUNK_GENERATOR

   239 static JSC_CONST_HASHTABLE HashTable JSElementPrototypeTable = { 69, 63, JSElementPrototypeTableValues, 0 };

   240 const ClassInfo JSElementPrototype::s_info = { "ElementPrototype", 0, &JSElementPrototypeTable, 0 };

   241 

   242 JSObject* JSElementPrototype::self(ExecState* exec, JSGlobalObject* globalObject)

   243 {

   244     return getDOMPrototype<JSElement>(exec, globalObject);

   245 }

   246 

   247 bool JSElementPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   248 {

   249     return getStaticFunctionSlot<JSObject>(exec, &JSElementPrototypeTable, this, propertyName, slot);

   250 }

   251 

   252 bool JSElementPrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   253 {

   254     return getStaticFunctionDescriptor<JSObject>(exec, &JSElementPrototypeTable, this, propertyName, descriptor);

   255 }

   256 

   257 const ClassInfo JSElement::s_info = { "Element", &JSNode::s_info, &JSElementTable, 0 };

   258 

   259 JSElement::JSElement(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<Element> impl)

   260     : JSNode(structure, globalObject, impl)

   261 {

   262 }

   263 

   264 JSObject* JSElement::createPrototype(ExecState* exec, JSGlobalObject* globalObject)

   265 {

   266     return new (exec) JSElementPrototype(globalObject, JSElementPrototype::createStructure(JSNodePrototype::self(exec, globalObject)));

   267 }

   268 

   269 JSValue jsElementTagName(ExecState* exec, JSValue slotBase, const Identifier&)

   270 {

   271     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   272     UNUSED_PARAM(exec);

   273     Element* imp = static_cast<Element*>(castedThis->impl());

   274     JSValue result = jsStringOrNull(exec, imp->tagName());

   275     return result;

   276 }

   277 

   278 JSValue jsElementStyle(ExecState* exec, JSValue slotBase, const Identifier&)

   279 {

   280     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   281     UNUSED_PARAM(exec);

   282     Element* imp = static_cast<Element*>(castedThis->impl());

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

   284     return result;

   285 }

   286 

   287 JSValue jsElementOffsetLeft(ExecState* exec, JSValue slotBase, const Identifier&)

   288 {

   289     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   290     UNUSED_PARAM(exec);

   291     Element* imp = static_cast<Element*>(castedThis->impl());

   292     JSValue result = jsNumber(exec, imp->offsetLeft());

   293     return result;

   294 }

   295 

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

   297 {

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

   299     UNUSED_PARAM(exec);

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

   301     JSValue result = jsNumber(exec, imp->offsetTop());

   302     return result;

   303 }

   304 

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

   306 {

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

   308     UNUSED_PARAM(exec);

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

   310     JSValue result = jsNumber(exec, imp->offsetWidth());

   311     return result;

   312 }

   313 

   314 JSValue jsElementOffsetHeight(ExecState* exec, JSValue slotBase, const Identifier&)

   315 {

   316     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   317     UNUSED_PARAM(exec);

   318     Element* imp = static_cast<Element*>(castedThis->impl());

   319     JSValue result = jsNumber(exec, imp->offsetHeight());

   320     return result;

   321 }

   322 

   323 JSValue jsElementOffsetParent(ExecState* exec, JSValue slotBase, const Identifier&)

   324 {

   325     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   326     UNUSED_PARAM(exec);

   327     Element* imp = static_cast<Element*>(castedThis->impl());

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

   329     return result;

   330 }

   331 

   332 JSValue jsElementClientLeft(ExecState* exec, JSValue slotBase, const Identifier&)

   333 {

   334     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   335     UNUSED_PARAM(exec);

   336     Element* imp = static_cast<Element*>(castedThis->impl());

   337     JSValue result = jsNumber(exec, imp->clientLeft());

   338     return result;

   339 }

   340 

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

   342 {

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

   344     UNUSED_PARAM(exec);

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

   346     JSValue result = jsNumber(exec, imp->clientTop());

   347     return result;

   348 }

   349 

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

   351 {

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

   353     UNUSED_PARAM(exec);

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

   355     JSValue result = jsNumber(exec, imp->clientWidth());

   356     return result;

   357 }

   358 

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

   360 {

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

   362     UNUSED_PARAM(exec);

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

   364     JSValue result = jsNumber(exec, imp->clientHeight());

   365     return result;

   366 }

   367 

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

   369 {

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

   371     UNUSED_PARAM(exec);

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

   373     JSValue result = jsNumber(exec, imp->scrollLeft());

   374     return result;

   375 }

   376 

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

   378 {

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

   380     UNUSED_PARAM(exec);

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

   382     JSValue result = jsNumber(exec, imp->scrollTop());

   383     return result;

   384 }

   385 

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

   387 {

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

   389     UNUSED_PARAM(exec);

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

   391     JSValue result = jsNumber(exec, imp->scrollWidth());

   392     return result;

   393 }

   394 

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

   396 {

   397     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   398     UNUSED_PARAM(exec);

   399     Element* imp = static_cast<Element*>(castedThis->impl());

   400     JSValue result = jsNumber(exec, imp->scrollHeight());

   401     return result;

   402 }

   403 

   404 JSValue jsElementDataset(ExecState* exec, JSValue slotBase, const Identifier&)

   405 {

   406     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   407     UNUSED_PARAM(exec);

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

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

   410     return result;

   411 }

   412 

   413 JSValue jsElementFirstElementChild(ExecState* exec, JSValue slotBase, const Identifier&)

   414 {

   415     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   416     UNUSED_PARAM(exec);

   417     Element* imp = static_cast<Element*>(castedThis->impl());

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

   419     return result;

   420 }

   421 

   422 JSValue jsElementLastElementChild(ExecState* exec, JSValue slotBase, const Identifier&)

   423 {

   424     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   425     UNUSED_PARAM(exec);

   426     Element* imp = static_cast<Element*>(castedThis->impl());

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

   428     return result;

   429 }

   430 

   431 JSValue jsElementPreviousElementSibling(ExecState* exec, JSValue slotBase, const Identifier&)

   432 {

   433     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   434     UNUSED_PARAM(exec);

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

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

   437     return result;

   438 }

   439 

   440 JSValue jsElementNextElementSibling(ExecState* exec, JSValue slotBase, const Identifier&)

   441 {

   442     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   443     UNUSED_PARAM(exec);

   444     Element* imp = static_cast<Element*>(castedThis->impl());

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

   446     return result;

   447 }

   448 

   449 JSValue jsElementChildElementCount(ExecState* exec, JSValue slotBase, const Identifier&)

   450 {

   451     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   452     UNUSED_PARAM(exec);

   453     Element* imp = static_cast<Element*>(castedThis->impl());

   454     JSValue result = jsNumber(exec, imp->childElementCount());

   455     return result;

   456 }

   457 

   458 JSValue jsElementOnabort(ExecState* exec, JSValue slotBase, const Identifier&)

   459 {

   460     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   461     UNUSED_PARAM(exec);

   462     Element* imp = static_cast<Element*>(castedThis->impl());

   463     if (EventListener* listener = imp->onabort()) {

   464         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   465             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   466                 return jsFunction;

   467         }

   468     }

   469     return jsNull();

   470 }

   471 

   472 JSValue jsElementOnblur(ExecState* exec, JSValue slotBase, const Identifier&)

   473 {

   474     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   475     UNUSED_PARAM(exec);

   476     Element* imp = static_cast<Element*>(castedThis->impl());

   477     if (EventListener* listener = imp->onblur()) {

   478         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   479             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   480                 return jsFunction;

   481         }

   482     }

   483     return jsNull();

   484 }

   485 

   486 JSValue jsElementOnchange(ExecState* exec, JSValue slotBase, const Identifier&)

   487 {

   488     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   489     UNUSED_PARAM(exec);

   490     Element* imp = static_cast<Element*>(castedThis->impl());

   491     if (EventListener* listener = imp->onchange()) {

   492         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   493             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   494                 return jsFunction;

   495         }

   496     }

   497     return jsNull();

   498 }

   499 

   500 JSValue jsElementOnclick(ExecState* exec, JSValue slotBase, const Identifier&)

   501 {

   502     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   503     UNUSED_PARAM(exec);

   504     Element* imp = static_cast<Element*>(castedThis->impl());

   505     if (EventListener* listener = imp->onclick()) {

   506         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   507             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   508                 return jsFunction;

   509         }

   510     }

   511     return jsNull();

   512 }

   513 

   514 JSValue jsElementOncontextmenu(ExecState* exec, JSValue slotBase, const Identifier&)

   515 {

   516     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   517     UNUSED_PARAM(exec);

   518     Element* imp = static_cast<Element*>(castedThis->impl());

   519     if (EventListener* listener = imp->oncontextmenu()) {

   520         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   521             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   522                 return jsFunction;

   523         }

   524     }

   525     return jsNull();

   526 }

   527 

   528 JSValue jsElementOndblclick(ExecState* exec, JSValue slotBase, const Identifier&)

   529 {

   530     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   531     UNUSED_PARAM(exec);

   532     Element* imp = static_cast<Element*>(castedThis->impl());

   533     if (EventListener* listener = imp->ondblclick()) {

   534         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   535             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   536                 return jsFunction;

   537         }

   538     }

   539     return jsNull();

   540 }

   541 

   542 JSValue jsElementOndrag(ExecState* exec, JSValue slotBase, const Identifier&)

   543 {

   544     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   545     UNUSED_PARAM(exec);

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

   547     if (EventListener* listener = imp->ondrag()) {

   548         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   549             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   550                 return jsFunction;

   551         }

   552     }

   553     return jsNull();

   554 }

   555 

   556 JSValue jsElementOndragend(ExecState* exec, JSValue slotBase, const Identifier&)

   557 {

   558     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   559     UNUSED_PARAM(exec);

   560     Element* imp = static_cast<Element*>(castedThis->impl());

   561     if (EventListener* listener = imp->ondragend()) {

   562         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   563             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   564                 return jsFunction;

   565         }

   566     }

   567     return jsNull();

   568 }

   569 

   570 JSValue jsElementOndragenter(ExecState* exec, JSValue slotBase, const Identifier&)

   571 {

   572     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   573     UNUSED_PARAM(exec);

   574     Element* imp = static_cast<Element*>(castedThis->impl());

   575     if (EventListener* listener = imp->ondragenter()) {

   576         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   577             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   578                 return jsFunction;

   579         }

   580     }

   581     return jsNull();

   582 }

   583 

   584 JSValue jsElementOndragleave(ExecState* exec, JSValue slotBase, const Identifier&)

   585 {

   586     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   587     UNUSED_PARAM(exec);

   588     Element* imp = static_cast<Element*>(castedThis->impl());

   589     if (EventListener* listener = imp->ondragleave()) {

   590         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   591             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   592                 return jsFunction;

   593         }

   594     }

   595     return jsNull();

   596 }

   597 

   598 JSValue jsElementOndragover(ExecState* exec, JSValue slotBase, const Identifier&)

   599 {

   600     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   601     UNUSED_PARAM(exec);

   602     Element* imp = static_cast<Element*>(castedThis->impl());

   603     if (EventListener* listener = imp->ondragover()) {

   604         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   605             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   606                 return jsFunction;

   607         }

   608     }

   609     return jsNull();

   610 }

   611 

   612 JSValue jsElementOndragstart(ExecState* exec, JSValue slotBase, const Identifier&)

   613 {

   614     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   615     UNUSED_PARAM(exec);

   616     Element* imp = static_cast<Element*>(castedThis->impl());

   617     if (EventListener* listener = imp->ondragstart()) {

   618         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   619             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   620                 return jsFunction;

   621         }

   622     }

   623     return jsNull();

   624 }

   625 

   626 JSValue jsElementOndrop(ExecState* exec, JSValue slotBase, const Identifier&)

   627 {

   628     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   629     UNUSED_PARAM(exec);

   630     Element* imp = static_cast<Element*>(castedThis->impl());

   631     if (EventListener* listener = imp->ondrop()) {

   632         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   633             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   634                 return jsFunction;

   635         }

   636     }

   637     return jsNull();

   638 }

   639 

   640 JSValue jsElementOnerror(ExecState* exec, JSValue slotBase, const Identifier&)

   641 {

   642     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   643     UNUSED_PARAM(exec);

   644     Element* imp = static_cast<Element*>(castedThis->impl());

   645     if (EventListener* listener = imp->onerror()) {

   646         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   647             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   648                 return jsFunction;

   649         }

   650     }

   651     return jsNull();

   652 }

   653 

   654 JSValue jsElementOnfocus(ExecState* exec, JSValue slotBase, const Identifier&)

   655 {

   656     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   657     UNUSED_PARAM(exec);

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

   659     if (EventListener* listener = imp->onfocus()) {

   660         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   661             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   662                 return jsFunction;

   663         }

   664     }

   665     return jsNull();

   666 }

   667 

   668 JSValue jsElementOninput(ExecState* exec, JSValue slotBase, const Identifier&)

   669 {

   670     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   671     UNUSED_PARAM(exec);

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

   673     if (EventListener* listener = imp->oninput()) {

   674         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   675             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   676                 return jsFunction;

   677         }

   678     }

   679     return jsNull();

   680 }

   681 

   682 JSValue jsElementOninvalid(ExecState* exec, JSValue slotBase, const Identifier&)

   683 {

   684     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   685     UNUSED_PARAM(exec);

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

   687     if (EventListener* listener = imp->oninvalid()) {

   688         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   689             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   690                 return jsFunction;

   691         }

   692     }

   693     return jsNull();

   694 }

   695 

   696 JSValue jsElementOnkeydown(ExecState* exec, JSValue slotBase, const Identifier&)

   697 {

   698     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   699     UNUSED_PARAM(exec);

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

   701     if (EventListener* listener = imp->onkeydown()) {

   702         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   703             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   704                 return jsFunction;

   705         }

   706     }

   707     return jsNull();

   708 }

   709 

   710 JSValue jsElementOnkeypress(ExecState* exec, JSValue slotBase, const Identifier&)

   711 {

   712     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   713     UNUSED_PARAM(exec);

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

   715     if (EventListener* listener = imp->onkeypress()) {

   716         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   717             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   718                 return jsFunction;

   719         }

   720     }

   721     return jsNull();

   722 }

   723 

   724 JSValue jsElementOnkeyup(ExecState* exec, JSValue slotBase, const Identifier&)

   725 {

   726     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   727     UNUSED_PARAM(exec);

   728     Element* imp = static_cast<Element*>(castedThis->impl());

   729     if (EventListener* listener = imp->onkeyup()) {

   730         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   731             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   732                 return jsFunction;

   733         }

   734     }

   735     return jsNull();

   736 }

   737 

   738 JSValue jsElementOnload(ExecState* exec, JSValue slotBase, const Identifier&)

   739 {

   740     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   741     UNUSED_PARAM(exec);

   742     Element* imp = static_cast<Element*>(castedThis->impl());

   743     if (EventListener* listener = imp->onload()) {

   744         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   745             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   746                 return jsFunction;

   747         }

   748     }

   749     return jsNull();

   750 }

   751 

   752 JSValue jsElementOnmousedown(ExecState* exec, JSValue slotBase, const Identifier&)

   753 {

   754     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   755     UNUSED_PARAM(exec);

   756     Element* imp = static_cast<Element*>(castedThis->impl());

   757     if (EventListener* listener = imp->onmousedown()) {

   758         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   759             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   760                 return jsFunction;

   761         }

   762     }

   763     return jsNull();

   764 }

   765 

   766 JSValue jsElementOnmousemove(ExecState* exec, JSValue slotBase, const Identifier&)

   767 {

   768     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   769     UNUSED_PARAM(exec);

   770     Element* imp = static_cast<Element*>(castedThis->impl());

   771     if (EventListener* listener = imp->onmousemove()) {

   772         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   773             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   774                 return jsFunction;

   775         }

   776     }

   777     return jsNull();

   778 }

   779 

   780 JSValue jsElementOnmouseout(ExecState* exec, JSValue slotBase, const Identifier&)

   781 {

   782     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   783     UNUSED_PARAM(exec);

   784     Element* imp = static_cast<Element*>(castedThis->impl());

   785     if (EventListener* listener = imp->onmouseout()) {

   786         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   787             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   788                 return jsFunction;

   789         }

   790     }

   791     return jsNull();

   792 }

   793 

   794 JSValue jsElementOnmouseover(ExecState* exec, JSValue slotBase, const Identifier&)

   795 {

   796     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   797     UNUSED_PARAM(exec);

   798     Element* imp = static_cast<Element*>(castedThis->impl());

   799     if (EventListener* listener = imp->onmouseover()) {

   800         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   801             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   802                 return jsFunction;

   803         }

   804     }

   805     return jsNull();

   806 }

   807 

   808 JSValue jsElementOnmouseup(ExecState* exec, JSValue slotBase, const Identifier&)

   809 {

   810     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   811     UNUSED_PARAM(exec);

   812     Element* imp = static_cast<Element*>(castedThis->impl());

   813     if (EventListener* listener = imp->onmouseup()) {

   814         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   815             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   816                 return jsFunction;

   817         }

   818     }

   819     return jsNull();

   820 }

   821 

   822 JSValue jsElementOnmousewheel(ExecState* exec, JSValue slotBase, const Identifier&)

   823 {

   824     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   825     UNUSED_PARAM(exec);

   826     Element* imp = static_cast<Element*>(castedThis->impl());

   827     if (EventListener* listener = imp->onmousewheel()) {

   828         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   829             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   830                 return jsFunction;

   831         }

   832     }

   833     return jsNull();

   834 }

   835 

   836 JSValue jsElementOnscroll(ExecState* exec, JSValue slotBase, const Identifier&)

   837 {

   838     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   839     UNUSED_PARAM(exec);

   840     Element* imp = static_cast<Element*>(castedThis->impl());

   841     if (EventListener* listener = imp->onscroll()) {

   842         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   843             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   844                 return jsFunction;

   845         }

   846     }

   847     return jsNull();

   848 }

   849 

   850 JSValue jsElementOnselect(ExecState* exec, JSValue slotBase, const Identifier&)

   851 {

   852     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   853     UNUSED_PARAM(exec);

   854     Element* imp = static_cast<Element*>(castedThis->impl());

   855     if (EventListener* listener = imp->onselect()) {

   856         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   857             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   858                 return jsFunction;

   859         }

   860     }

   861     return jsNull();

   862 }

   863 

   864 JSValue jsElementOnsubmit(ExecState* exec, JSValue slotBase, const Identifier&)

   865 {

   866     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   867     UNUSED_PARAM(exec);

   868     Element* imp = static_cast<Element*>(castedThis->impl());

   869     if (EventListener* listener = imp->onsubmit()) {

   870         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   871             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   872                 return jsFunction;

   873         }

   874     }

   875     return jsNull();

   876 }

   877 

   878 JSValue jsElementOnbeforecut(ExecState* exec, JSValue slotBase, const Identifier&)

   879 {

   880     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   881     UNUSED_PARAM(exec);

   882     Element* imp = static_cast<Element*>(castedThis->impl());

   883     if (EventListener* listener = imp->onbeforecut()) {

   884         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   885             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   886                 return jsFunction;

   887         }

   888     }

   889     return jsNull();

   890 }

   891 

   892 JSValue jsElementOncut(ExecState* exec, JSValue slotBase, const Identifier&)

   893 {

   894     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   895     UNUSED_PARAM(exec);

   896     Element* imp = static_cast<Element*>(castedThis->impl());

   897     if (EventListener* listener = imp->oncut()) {

   898         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   899             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   900                 return jsFunction;

   901         }

   902     }

   903     return jsNull();

   904 }

   905 

   906 JSValue jsElementOnbeforecopy(ExecState* exec, JSValue slotBase, const Identifier&)

   907 {

   908     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   909     UNUSED_PARAM(exec);

   910     Element* imp = static_cast<Element*>(castedThis->impl());

   911     if (EventListener* listener = imp->onbeforecopy()) {

   912         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   913             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   914                 return jsFunction;

   915         }

   916     }

   917     return jsNull();

   918 }

   919 

   920 JSValue jsElementOncopy(ExecState* exec, JSValue slotBase, const Identifier&)

   921 {

   922     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   923     UNUSED_PARAM(exec);

   924     Element* imp = static_cast<Element*>(castedThis->impl());

   925     if (EventListener* listener = imp->oncopy()) {

   926         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   927             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   928                 return jsFunction;

   929         }

   930     }

   931     return jsNull();

   932 }

   933 

   934 JSValue jsElementOnbeforepaste(ExecState* exec, JSValue slotBase, const Identifier&)

   935 {

   936     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   937     UNUSED_PARAM(exec);

   938     Element* imp = static_cast<Element*>(castedThis->impl());

   939     if (EventListener* listener = imp->onbeforepaste()) {

   940         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   941             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   942                 return jsFunction;

   943         }

   944     }

   945     return jsNull();

   946 }

   947 

   948 JSValue jsElementOnpaste(ExecState* exec, JSValue slotBase, const Identifier&)

   949 {

   950     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   951     UNUSED_PARAM(exec);

   952     Element* imp = static_cast<Element*>(castedThis->impl());

   953     if (EventListener* listener = imp->onpaste()) {

   954         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   955             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   956                 return jsFunction;

   957         }

   958     }

   959     return jsNull();

   960 }

   961 

   962 JSValue jsElementOnreset(ExecState* exec, JSValue slotBase, const Identifier&)

   963 {

   964     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   965     UNUSED_PARAM(exec);

   966     Element* imp = static_cast<Element*>(castedThis->impl());

   967     if (EventListener* listener = imp->onreset()) {

   968         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   969             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   970                 return jsFunction;

   971         }

   972     }

   973     return jsNull();

   974 }

   975 

   976 JSValue jsElementOnsearch(ExecState* exec, JSValue slotBase, const Identifier&)

   977 {

   978     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   979     UNUSED_PARAM(exec);

   980     Element* imp = static_cast<Element*>(castedThis->impl());

   981     if (EventListener* listener = imp->onsearch()) {

   982         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   983             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   984                 return jsFunction;

   985         }

   986     }

   987     return jsNull();

   988 }

   989 

   990 JSValue jsElementOnselectstart(ExecState* exec, JSValue slotBase, const Identifier&)

   991 {

   992     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

   993     UNUSED_PARAM(exec);

   994     Element* imp = static_cast<Element*>(castedThis->impl());

   995     if (EventListener* listener = imp->onselectstart()) {

   996         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

   997             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

   998                 return jsFunction;

   999         }

  1000     }

  1001     return jsNull();

  1002 }

  1003 

  1004 #if ENABLE(TOUCH_EVENTS)

  1005 JSValue jsElementOntouchstart(ExecState* exec, JSValue slotBase, const Identifier&)

  1006 {

  1007     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

  1008     UNUSED_PARAM(exec);

  1009     Element* imp = static_cast<Element*>(castedThis->impl());

  1010     if (EventListener* listener = imp->ontouchstart()) {

  1011         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

  1012             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

  1013                 return jsFunction;

  1014         }

  1015     }

  1016     return jsNull();

  1017 }

  1018 #endif

  1019 

  1020 #if ENABLE(TOUCH_EVENTS)

  1021 JSValue jsElementOntouchmove(ExecState* exec, JSValue slotBase, const Identifier&)

  1022 {

  1023     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

  1024     UNUSED_PARAM(exec);

  1025     Element* imp = static_cast<Element*>(castedThis->impl());

  1026     if (EventListener* listener = imp->ontouchmove()) {

  1027         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

  1028             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

  1029                 return jsFunction;

  1030         }

  1031     }

  1032     return jsNull();

  1033 }

  1034 #endif

  1035 

  1036 #if ENABLE(TOUCH_EVENTS)

  1037 JSValue jsElementOntouchend(ExecState* exec, JSValue slotBase, const Identifier&)

  1038 {

  1039     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

  1040     UNUSED_PARAM(exec);

  1041     Element* imp = static_cast<Element*>(castedThis->impl());

  1042     if (EventListener* listener = imp->ontouchend()) {

  1043         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

  1044             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

  1045                 return jsFunction;

  1046         }

  1047     }

  1048     return jsNull();

  1049 }

  1050 #endif

  1051 

  1052 #if ENABLE(TOUCH_EVENTS)

  1053 JSValue jsElementOntouchcancel(ExecState* exec, JSValue slotBase, const Identifier&)

  1054 {

  1055     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

  1056     UNUSED_PARAM(exec);

  1057     Element* imp = static_cast<Element*>(castedThis->impl());

  1058     if (EventListener* listener = imp->ontouchcancel()) {

  1059         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

  1060             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

  1061                 return jsFunction;

  1062         }

  1063     }

  1064     return jsNull();

  1065 }

  1066 #endif

  1067 

  1068 #if ENABLE(TRANSFORMACTION_EVENTS)

  1069 JSValue jsElementOntransformactionstart(ExecState* exec, JSValue slotBase, const Identifier&)

  1070 {

  1071     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

  1072     UNUSED_PARAM(exec);

  1073     Element* imp = static_cast<Element*>(castedThis->impl());

  1074     if (EventListener* listener = imp->ontransformactionstart()) {

  1075         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

  1076             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

  1077                 return jsFunction;

  1078         }

  1079     }

  1080     return jsNull();

  1081 }

  1082 #endif

  1083 

  1084 #if ENABLE(TRANSFORMACTION_EVENTS)

  1085 JSValue jsElementOntransformactionupdate(ExecState* exec, JSValue slotBase, const Identifier&)

  1086 {

  1087     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

  1088     UNUSED_PARAM(exec);

  1089     Element* imp = static_cast<Element*>(castedThis->impl());

  1090     if (EventListener* listener = imp->ontransformactionupdate()) {

  1091         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

  1092             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

  1093                 return jsFunction;

  1094         }

  1095     }

  1096     return jsNull();

  1097 }

  1098 #endif

  1099 

  1100 #if ENABLE(TRANSFORMACTION_EVENTS)

  1101 JSValue jsElementOntransformactionend(ExecState* exec, JSValue slotBase, const Identifier&)

  1102 {

  1103     JSElement* castedThis = static_cast<JSElement*>(asObject(slotBase));

  1104     UNUSED_PARAM(exec);

  1105     Element* imp = static_cast<Element*>(castedThis->impl());

  1106     if (EventListener* listener = imp->ontransformactionend()) {

  1107         if (const JSEventListener* jsListener = JSEventListener::cast(listener)) {

  1108             if (JSObject* jsFunction = jsListener->jsFunction(imp->scriptExecutionContext()))

  1109                 return jsFunction;

  1110         }

  1111     }

  1112     return jsNull();

  1113 }

  1114 #endif

  1115 

  1116 JSValue jsElementConstructor(ExecState* exec, JSValue slotBase, const Identifier&)

  1117 {

  1118     JSElement* domObject = static_cast<JSElement*>(asObject(slotBase));

  1119     return JSElement::getConstructor(exec, domObject->globalObject());

  1120 }

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

  1122 {

  1123     lookupPut<JSElement, Base>(exec, propertyName, value, &JSElementTable, this, slot);

  1124 }

  1125 

  1126 void setJSElementScrollLeft(ExecState* exec, JSObject* thisObject, JSValue value)

  1127 {

  1128     JSElement* castedThis = static_cast<JSElement*>(thisObject);

  1129     Element* imp = static_cast<Element*>(castedThis->impl());

  1130     imp->setScrollLeft(value.toInt32(exec));

  1131 }

  1132 

  1133 void setJSElementScrollTop(ExecState* exec, JSObject* thisObject, JSValue value)

  1134 {

  1135     JSElement* castedThis = static_cast<JSElement*>(thisObject);