DerivedSources/WebCore/JSHTMLTableCellElement.cpp

   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 "JSHTMLTableCellElement.h"
  23
  24 #include "HTMLNames.h"
  25 #include "HTMLTableCellElement.h"
  26 #include "KURL.h"
  27 #include <runtime/JSString.h>
  28 #include <wtf/GetPtr.h>
  29
  30 using namespace JSC;
  31
  32 namespace WebCore {
  33
  34 ASSERT_CLASS_FITS_IN_CELL(JSHTMLTableCellElement);
  35
  36 /* Hash table */
  37 #if ENABLE(JIT)
  38 #define THUNK_GENERATOR(generator) , generator
  39 #else
  40 #define THUNK_GENERATOR(generator)
  41 #endif
  42 #if ENABLE(DFG_JIT)
  43 #define INTRINSIC(intrinsic) , intrinsic
  44 #else
  45 #define INTRINSIC(intrinsic)
  46 #endif
  47
  48 static const HashTableValue JSHTMLTableCellElementTableValues[] =
  49 {
  50     { "cellIndex", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementCellIndex), (intptr_t)0 THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  51     { "abbr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementAbbr), (intptr_t)setJSHTMLTableCellElementAbbr THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  52     { "align", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementAlign), (intptr_t)setJSHTMLTableCellElementAlign THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  53     { "axis", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementAxis), (intptr_t)setJSHTMLTableCellElementAxis THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  54     { "bgColor", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementBgColor), (intptr_t)setJSHTMLTableCellElementBgColor THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  55     { "ch", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementCh), (intptr_t)setJSHTMLTableCellElementCh THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  56     { "chOff", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementChOff), (intptr_t)setJSHTMLTableCellElementChOff THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  57     { "colSpan", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementColSpan), (intptr_t)setJSHTMLTableCellElementColSpan THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  58     { "headers", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementHeaders), (intptr_t)setJSHTMLTableCellElementHeaders THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  59     { "height", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementHeight), (intptr_t)setJSHTMLTableCellElementHeight THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  60     { "noWrap", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementNoWrap), (intptr_t)setJSHTMLTableCellElementNoWrap THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  61     { "rowSpan", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementRowSpan), (intptr_t)setJSHTMLTableCellElementRowSpan THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  62     { "scope", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementScope), (intptr_t)setJSHTMLTableCellElementScope THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  63     { "vAlign", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementVAlign), (intptr_t)setJSHTMLTableCellElementVAlign THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  64     { "width", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementWidth), (intptr_t)setJSHTMLTableCellElementWidth THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  65     { "constructor", DontEnum | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementConstructor), (intptr_t)0 THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) },
  66     { 0, 0, 0, 0 THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) }
  67 };
  68
  69 #undef THUNK_GENERATOR
  70 static const HashTable JSHTMLTableCellElementTable = { 36, 31, JSHTMLTableCellElementTableValues, 0 };
  71 /* Hash table for constructor */
  72 #if ENABLE(JIT)
  73 #define THUNK_GENERATOR(generator) , generator
  74 #else
  75 #define THUNK_GENERATOR(generator)
  76 #endif
  77 #if ENABLE(DFG_JIT)
  78 #define INTRINSIC(intrinsic) , intrinsic
  79 #else
  80 #define INTRINSIC(intrinsic)
  81 #endif
  82
  83 static const HashTableValue JSHTMLTableCellElementConstructorTableValues[] =
  84 {
  85     { 0, 0, 0, 0 THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) }
  86 };
  87
  88 #undef THUNK_GENERATOR
  89 static const HashTable JSHTMLTableCellElementConstructorTable = { 1, 0, JSHTMLTableCellElementConstructorTableValues, 0 };
  90 const ClassInfo JSHTMLTableCellElementConstructor::s_info = { "HTMLTableCellElementConstructor", &DOMConstructorObject::s_info, &JSHTMLTableCellElementConstructorTable, 0, CREATE_METHOD_TABLE(JSHTMLTableCellElementConstructor) };
  91
  92 JSHTMLTableCellElementConstructor::JSHTMLTableCellElementConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
  93     : DOMConstructorObject(structure, globalObject)
  94 {
  95 }
  96
  97 void JSHTMLTableCellElementConstructor::finishCreation(ExecState* exec, JSDOMGlobalObject* globalObject)
  98 {
  99     Base::finishCreation(exec->globalData());
 100     ASSERT(inherits(&s_info));
 101     putDirect(exec->globalData(), exec->propertyNames().prototype, JSHTMLTableCellElementPrototype::self(exec, globalObject), DontDelete | ReadOnly);
 102 }
 103
 104 bool JSHTMLTableCellElementConstructor::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 105 {
 106     return getStaticValueSlot<JSHTMLTableCellElementConstructor, JSDOMWrapper>(exec, &JSHTMLTableCellElementConstructorTable, static_cast<JSHTMLTableCellElementConstructor*>(cell), propertyName, slot);
 107 }
 108
 109 bool JSHTMLTableCellElementConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 110 {
 111     return getStaticValueDescriptor<JSHTMLTableCellElementConstructor, JSDOMWrapper>(exec, &JSHTMLTableCellElementConstructorTable, static_cast<JSHTMLTableCellElementConstructor*>(object), propertyName, descriptor);
 112 }
 113
 114 /* Hash table for prototype */
 115 #if ENABLE(JIT)
 116 #define THUNK_GENERATOR(generator) , generator
 117 #else
 118 #define THUNK_GENERATOR(generator)
 119 #endif
 120 #if ENABLE(DFG_JIT)
 121 #define INTRINSIC(intrinsic) , intrinsic
 122 #else
 123 #define INTRINSIC(intrinsic)
 124 #endif
 125
 126 static const HashTableValue JSHTMLTableCellElementPrototypeTableValues[] =
 127 {
 128     { 0, 0, 0, 0 THUNK_GENERATOR(0) INTRINSIC(DFG::NoIntrinsic) }
 129 };
 130
 131 #undef THUNK_GENERATOR
 132 static const HashTable JSHTMLTableCellElementPrototypeTable = { 1, 0, JSHTMLTableCellElementPrototypeTableValues, 0 };
 133 const ClassInfo JSHTMLTableCellElementPrototype::s_info = { "HTMLTableCellElementPrototype", &JSC::JSNonFinalObject::s_info, &JSHTMLTableCellElementPrototypeTable, 0, CREATE_METHOD_TABLE(JSHTMLTableCellElementPrototype) };
 134
 135 JSObject* JSHTMLTableCellElementPrototype::self(ExecState* exec, JSGlobalObject* globalObject)
 136 {
 137     return getDOMPrototype<JSHTMLTableCellElement>(exec, globalObject);
 138 }
 139
 140 const ClassInfo JSHTMLTableCellElement::s_info = { "HTMLTableCellElement", &JSHTMLElement::s_info, &JSHTMLTableCellElementTable, 0 , CREATE_METHOD_TABLE(JSHTMLTableCellElement) };
 141
 142 JSHTMLTableCellElement::JSHTMLTableCellElement(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<HTMLTableCellElement> impl)
 143     : JSHTMLElement(structure, globalObject, impl)
 144 {
 145 }
 146
 147 void JSHTMLTableCellElement::finishCreation(JSGlobalData& globalData)
 148 {
 149     Base::finishCreation(globalData);
 150     ASSERT(inherits(&s_info));
 151 }
 152
 153 JSObject* JSHTMLTableCellElement::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
 154 {
 155     return JSHTMLTableCellElementPrototype::create(exec->globalData(), globalObject, JSHTMLTableCellElementPrototype::createStructure(exec->globalData(), globalObject, JSHTMLElementPrototype::self(exec, globalObject)));
 156 }
 157
 158 bool JSHTMLTableCellElement::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 159 {
 160     JSHTMLTableCellElement* thisObject = jsCast<JSHTMLTableCellElement*>(cell);
 161     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
 162     return getStaticValueSlot<JSHTMLTableCellElement, Base>(exec, &JSHTMLTableCellElementTable, thisObject, propertyName, slot);
 163 }
 164
 165 bool JSHTMLTableCellElement::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 166 {
 167     JSHTMLTableCellElement* thisObject = jsCast<JSHTMLTableCellElement*>(object);
 168     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
 169     return getStaticValueDescriptor<JSHTMLTableCellElement, Base>(exec, &JSHTMLTableCellElementTable, thisObject, propertyName, descriptor);
 170 }
 171
 172 JSValue jsHTMLTableCellElementCellIndex(ExecState* exec, JSValue slotBase, const Identifier&)
 173 {
 174     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 175     UNUSED_PARAM(exec);
 176     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 177     JSValue result = jsNumber(imp->cellIndex());
 178     return result;
 179 }
 180
 181
 182 JSValue jsHTMLTableCellElementAbbr(ExecState* exec, JSValue slotBase, const Identifier&)
 183 {
 184     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 185     UNUSED_PARAM(exec);
 186     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 187     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::abbrAttr));
 188     return result;
 189 }
 190
 191
 192 JSValue jsHTMLTableCellElementAlign(ExecState* exec, JSValue slotBase, const Identifier&)
 193 {
 194     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 195     UNUSED_PARAM(exec);
 196     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 197     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::alignAttr));
 198     return result;
 199 }
 200
 201
 202 JSValue jsHTMLTableCellElementAxis(ExecState* exec, JSValue slotBase, const Identifier&)
 203 {
 204     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 205     UNUSED_PARAM(exec);
 206     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 207     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::axisAttr));
 208     return result;
 209 }
 210
 211
 212 JSValue jsHTMLTableCellElementBgColor(ExecState* exec, JSValue slotBase, const Identifier&)
 213 {
 214     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 215     UNUSED_PARAM(exec);
 216     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 217     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::bgcolorAttr));
 218     return result;
 219 }
 220
 221
 222 JSValue jsHTMLTableCellElementCh(ExecState* exec, JSValue slotBase, const Identifier&)
 223 {
 224     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 225     UNUSED_PARAM(exec);
 226     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 227     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::charAttr));
 228     return result;
 229 }
 230
 231
 232 JSValue jsHTMLTableCellElementChOff(ExecState* exec, JSValue slotBase, const Identifier&)
 233 {
 234     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 235     UNUSED_PARAM(exec);
 236     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 237     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::charoffAttr));
 238     return result;
 239 }
 240
 241
 242 JSValue jsHTMLTableCellElementColSpan(ExecState* exec, JSValue slotBase, const Identifier&)
 243 {
 244     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 245     UNUSED_PARAM(exec);
 246     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 247     JSValue result = jsNumber(imp->colSpan());
 248     return result;
 249 }
 250
 251
 252 JSValue jsHTMLTableCellElementHeaders(ExecState* exec, JSValue slotBase, const Identifier&)
 253 {
 254     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 255     UNUSED_PARAM(exec);
 256     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 257     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::headersAttr));
 258     return result;
 259 }
 260
 261
 262 JSValue jsHTMLTableCellElementHeight(ExecState* exec, JSValue slotBase, const Identifier&)
 263 {
 264     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 265     UNUSED_PARAM(exec);
 266     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 267     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::heightAttr));
 268     return result;
 269 }
 270
 271
 272 JSValue jsHTMLTableCellElementNoWrap(ExecState* exec, JSValue slotBase, const Identifier&)
 273 {
 274     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 275     UNUSED_PARAM(exec);
 276     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 277     JSValue result = jsBoolean(imp->hasAttribute(WebCore::HTMLNames::nowrapAttr));
 278     return result;
 279 }
 280
 281
 282 JSValue jsHTMLTableCellElementRowSpan(ExecState* exec, JSValue slotBase, const Identifier&)
 283 {
 284     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 285     UNUSED_PARAM(exec);
 286     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 287     JSValue result = jsNumber(imp->rowSpan());
 288     return result;
 289 }
 290
 291
 292 JSValue jsHTMLTableCellElementScope(ExecState* exec, JSValue slotBase, const Identifier&)
 293 {
 294     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 295     UNUSED_PARAM(exec);
 296     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 297     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::scopeAttr));
 298     return result;
 299 }
 300
 301
 302 JSValue jsHTMLTableCellElementVAlign(ExecState* exec, JSValue slotBase, const Identifier&)
 303 {
 304     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 305     UNUSED_PARAM(exec);
 306     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 307     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::valignAttr));
 308     return result;
 309 }
 310
 311
 312 JSValue jsHTMLTableCellElementWidth(ExecState* exec, JSValue slotBase, const Identifier&)
 313 {
 314     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 315     UNUSED_PARAM(exec);
 316     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 317     JSValue result = jsString(exec, imp->getAttribute(WebCore::HTMLNames::widthAttr));
 318     return result;
 319 }
 320
 321
 322 JSValue jsHTMLTableCellElementConstructor(ExecState* exec, JSValue slotBase, const Identifier&)
 323 {
 324     JSHTMLTableCellElement* domObject = static_cast<JSHTMLTableCellElement*>(asObject(slotBase));
 325     return JSHTMLTableCellElement::getConstructor(exec, domObject->globalObject());
 326 }
 327
 328 void JSHTMLTableCellElement::put(JSCell* cell, ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
 329 {
 330     JSHTMLTableCellElement* thisObject = jsCast<JSHTMLTableCellElement*>(cell);
 331     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
 332     lookupPut<JSHTMLTableCellElement, Base>(exec, propertyName, value, &JSHTMLTableCellElementTable, thisObject, slot);
 333 }
 334
 335 void setJSHTMLTableCellElementAbbr(ExecState* exec, JSObject* thisObject, JSValue value)
 336 {
 337     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 338     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 339     imp->setAttribute(WebCore::HTMLNames::abbrAttr, valueToStringWithNullCheck(exec, value));
 340 }
 341
 342
 343 void setJSHTMLTableCellElementAlign(ExecState* exec, JSObject* thisObject, JSValue value)
 344 {
 345     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 346     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 347     imp->setAttribute(WebCore::HTMLNames::alignAttr, valueToStringWithNullCheck(exec, value));
 348 }
 349
 350
 351 void setJSHTMLTableCellElementAxis(ExecState* exec, JSObject* thisObject, JSValue value)
 352 {
 353     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 354     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 355     imp->setAttribute(WebCore::HTMLNames::axisAttr, valueToStringWithNullCheck(exec, value));
 356 }
 357
 358
 359 void setJSHTMLTableCellElementBgColor(ExecState* exec, JSObject* thisObject, JSValue value)
 360 {
 361     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 362     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 363     imp->setAttribute(WebCore::HTMLNames::bgcolorAttr, valueToStringWithNullCheck(exec, value));
 364 }
 365
 366
 367 void setJSHTMLTableCellElementCh(ExecState* exec, JSObject* thisObject, JSValue value)
 368 {
 369     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 370     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 371     imp->setAttribute(WebCore::HTMLNames::charAttr, valueToStringWithNullCheck(exec, value));
 372 }
 373
 374
 375 void setJSHTMLTableCellElementChOff(ExecState* exec, JSObject* thisObject, JSValue value)
 376 {
 377     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 378     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 379     imp->setAttribute(WebCore::HTMLNames::charoffAttr, valueToStringWithNullCheck(exec, value));
 380 }
 381
 382
 383 void setJSHTMLTableCellElementColSpan(ExecState* exec, JSObject* thisObject, JSValue value)
 384 {
 385     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 386     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 387     imp->setColSpan(value.toInt32(exec));
 388 }
 389
 390
 391 void setJSHTMLTableCellElementHeaders(ExecState* exec, JSObject* thisObject, JSValue value)
 392 {
 393     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 394     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 395     imp->setAttribute(WebCore::HTMLNames::headersAttr, valueToStringWithNullCheck(exec, value));
 396 }
 397
 398
 399 void setJSHTMLTableCellElementHeight(ExecState* exec, JSObject* thisObject, JSValue value)
 400 {
 401     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 402     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 403     imp->setAttribute(WebCore::HTMLNames::heightAttr, valueToStringWithNullCheck(exec, value));
 404 }
 405
 406
 407 void setJSHTMLTableCellElementNoWrap(ExecState* exec, JSObject* thisObject, JSValue value)
 408 {
 409     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 410     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 411     imp->setBooleanAttribute(WebCore::HTMLNames::nowrapAttr, value.toBoolean(exec));
 412 }
 413
 414
 415 void setJSHTMLTableCellElementRowSpan(ExecState* exec, JSObject* thisObject, JSValue value)
 416 {
 417     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 418     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 419     imp->setRowSpan(value.toInt32(exec));
 420 }
 421
 422
 423 void setJSHTMLTableCellElementScope(ExecState* exec, JSObject* thisObject, JSValue value)
 424 {
 425     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 426     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 427     imp->setAttribute(WebCore::HTMLNames::scopeAttr, valueToStringWithNullCheck(exec, value));
 428 }
 429
 430
 431 void setJSHTMLTableCellElementVAlign(ExecState* exec, JSObject* thisObject, JSValue value)
 432 {
 433     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 434     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 435     imp->setAttribute(WebCore::HTMLNames::valignAttr, valueToStringWithNullCheck(exec, value));
 436 }
 437
 438
 439 void setJSHTMLTableCellElementWidth(ExecState* exec, JSObject* thisObject, JSValue value)
 440 {
 441     JSHTMLTableCellElement* castedThis = static_cast<JSHTMLTableCellElement*>(thisObject);
 442     HTMLTableCellElement* imp = static_cast<HTMLTableCellElement*>(castedThis->impl());
 443     imp->setAttribute(WebCore::HTMLNames::widthAttr, valueToStringWithNullCheck(exec, value));
 444 }
 445
 446
 447 JSValue JSHTMLTableCellElement::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
 448 {
 449     return getDOMConstructor<JSHTMLTableCellElementConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));
 450 }
 451
 452
 453 }