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

    23 

    24 #include "CanvasGradient.h"

    25 #include "CanvasPattern.h"

    26 #include "CanvasRenderingContext2D.h"

    27 #include "CanvasStyle.h"

    28 #include "ImageData.h"

    29 #include "JSCanvasGradient.h"

    30 #include "JSImageData.h"

    31 #include "JSTextMetrics.h"

    32 #include "KURL.h"

    33 #include "PlatformString.h"

    34 #include "TextMetrics.h"

    35 #include <runtime/Error.h>

    36 #include <runtime/JSNumberCell.h>

    37 #include <runtime/JSString.h>

    38 #include <wtf/GetPtr.h>

    39 

    40 using namespace JSC;

    41 

    42 namespace WebCore {

    43 

    44 ASSERT_CLASS_FITS_IN_CELL(JSCanvasRenderingContext2D);

    45 

    46 /* Hash table */

    47 #if ENABLE(JIT)

    48 #define THUNK_GENERATOR(generator) , generator

    49 #else

    50 #define THUNK_GENERATOR(generator)

    51 #endif

    52 

    53 static const HashTableValue JSCanvasRenderingContext2DTableValues[17] =

    54 {

    55     { "globalAlpha", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DGlobalAlpha), (intptr_t)setJSCanvasRenderingContext2DGlobalAlpha THUNK_GENERATOR(0) },

    56     { "globalCompositeOperation", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DGlobalCompositeOperation), (intptr_t)setJSCanvasRenderingContext2DGlobalCompositeOperation THUNK_GENERATOR(0) },

    57     { "lineWidth", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DLineWidth), (intptr_t)setJSCanvasRenderingContext2DLineWidth THUNK_GENERATOR(0) },

    58     { "lineCap", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DLineCap), (intptr_t)setJSCanvasRenderingContext2DLineCap THUNK_GENERATOR(0) },

    59     { "lineJoin", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DLineJoin), (intptr_t)setJSCanvasRenderingContext2DLineJoin THUNK_GENERATOR(0) },

    60     { "miterLimit", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DMiterLimit), (intptr_t)setJSCanvasRenderingContext2DMiterLimit THUNK_GENERATOR(0) },

    61     { "shadowOffsetX", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DShadowOffsetX), (intptr_t)setJSCanvasRenderingContext2DShadowOffsetX THUNK_GENERATOR(0) },

    62     { "shadowOffsetY", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DShadowOffsetY), (intptr_t)setJSCanvasRenderingContext2DShadowOffsetY THUNK_GENERATOR(0) },

    63     { "shadowBlur", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DShadowBlur), (intptr_t)setJSCanvasRenderingContext2DShadowBlur THUNK_GENERATOR(0) },

    64     { "shadowColor", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DShadowColor), (intptr_t)setJSCanvasRenderingContext2DShadowColor THUNK_GENERATOR(0) },

    65     { "font", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DFont), (intptr_t)setJSCanvasRenderingContext2DFont THUNK_GENERATOR(0) },

    66     { "textAlign", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DTextAlign), (intptr_t)setJSCanvasRenderingContext2DTextAlign THUNK_GENERATOR(0) },

    67     { "textBaseline", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DTextBaseline), (intptr_t)setJSCanvasRenderingContext2DTextBaseline THUNK_GENERATOR(0) },

    68     { "strokeStyle", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DStrokeStyle), (intptr_t)setJSCanvasRenderingContext2DStrokeStyle THUNK_GENERATOR(0) },

    69     { "fillStyle", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsCanvasRenderingContext2DFillStyle), (intptr_t)setJSCanvasRenderingContext2DFillStyle THUNK_GENERATOR(0) },

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

    71     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

    72 };

    73 

    74 #undef THUNK_GENERATOR

    75 static JSC_CONST_HASHTABLE HashTable JSCanvasRenderingContext2DTable = { 36, 31, JSCanvasRenderingContext2DTableValues, 0 };

    76 /* Hash table for constructor */

    77 #if ENABLE(JIT)

    78 #define THUNK_GENERATOR(generator) , generator

    79 #else

    80 #define THUNK_GENERATOR(generator)

    81 #endif

    82 

    83 static const HashTableValue JSCanvasRenderingContext2DConstructorTableValues[1] =

    84 {

    85     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

    86 };

    87 

    88 #undef THUNK_GENERATOR

    89 static JSC_CONST_HASHTABLE HashTable JSCanvasRenderingContext2DConstructorTable = { 1, 0, JSCanvasRenderingContext2DConstructorTableValues, 0 };

    90 class JSCanvasRenderingContext2DConstructor : public DOMConstructorObject {

    91 public:

    92     JSCanvasRenderingContext2DConstructor(JSC::ExecState*, JSDOMGlobalObject*);

    93 

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

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

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

    97     static const JSC::ClassInfo s_info;

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

    99     {

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

   101     }

   102 protected:

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

   104 };

   105 

   106 const ClassInfo JSCanvasRenderingContext2DConstructor::s_info = { "CanvasRenderingContext2DConstructor", 0, &JSCanvasRenderingContext2DConstructorTable, 0 };

   107 

   108 JSCanvasRenderingContext2DConstructor::JSCanvasRenderingContext2DConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)

   109     : DOMConstructorObject(JSCanvasRenderingContext2DConstructor::createStructure(globalObject->objectPrototype()), globalObject)

   110 {

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

   112 }

   113 

   114 bool JSCanvasRenderingContext2DConstructor::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   115 {

   116     return getStaticValueSlot<JSCanvasRenderingContext2DConstructor, DOMObject>(exec, &JSCanvasRenderingContext2DConstructorTable, this, propertyName, slot);

   117 }

   118 

   119 bool JSCanvasRenderingContext2DConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   120 {

   121     return getStaticValueDescriptor<JSCanvasRenderingContext2DConstructor, DOMObject>(exec, &JSCanvasRenderingContext2DConstructorTable, this, propertyName, descriptor);

   122 }

   123 

   124 /* Hash table for prototype */

   125 #if ENABLE(JIT)

   126 #define THUNK_GENERATOR(generator) , generator

   127 #else

   128 #define THUNK_GENERATOR(generator)

   129 #endif

   130 

   131 static const HashTableValue JSCanvasRenderingContext2DPrototypeTableValues[45] =

   132 {

   133     { "save", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSave), (intptr_t)0 THUNK_GENERATOR(0) },

   134     { "restore", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionRestore), (intptr_t)0 THUNK_GENERATOR(0) },

   135     { "scale", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionScale), (intptr_t)2 THUNK_GENERATOR(0) },

   136     { "rotate", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionRotate), (intptr_t)1 THUNK_GENERATOR(0) },

   137     { "translate", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionTranslate), (intptr_t)2 THUNK_GENERATOR(0) },

   138     { "transform", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionTransform), (intptr_t)6 THUNK_GENERATOR(0) },

   139     { "setTransform", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetTransform), (intptr_t)6 THUNK_GENERATOR(0) },

   140     { "createLinearGradient", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionCreateLinearGradient), (intptr_t)4 THUNK_GENERATOR(0) },

   141     { "createRadialGradient", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionCreateRadialGradient), (intptr_t)6 THUNK_GENERATOR(0) },

   142     { "clearRect", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionClearRect), (intptr_t)4 THUNK_GENERATOR(0) },

   143     { "fillRect", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionFillRect), (intptr_t)4 THUNK_GENERATOR(0) },

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

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

   146     { "moveTo", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionMoveTo), (intptr_t)2 THUNK_GENERATOR(0) },

   147     { "lineTo", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionLineTo), (intptr_t)2 THUNK_GENERATOR(0) },

   148     { "quadraticCurveTo", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionQuadraticCurveTo), (intptr_t)4 THUNK_GENERATOR(0) },

   149     { "bezierCurveTo", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionBezierCurveTo), (intptr_t)6 THUNK_GENERATOR(0) },

   150     { "arcTo", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionArcTo), (intptr_t)5 THUNK_GENERATOR(0) },

   151     { "rect", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionRect), (intptr_t)4 THUNK_GENERATOR(0) },

   152     { "arc", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionArc), (intptr_t)6 THUNK_GENERATOR(0) },

   153     { "fill", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionFill), (intptr_t)0 THUNK_GENERATOR(0) },

   154     { "stroke", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionStroke), (intptr_t)0 THUNK_GENERATOR(0) },

   155     { "clip", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionClip), (intptr_t)0 THUNK_GENERATOR(0) },

   156     { "isPointInPath", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionIsPointInPath), (intptr_t)2 THUNK_GENERATOR(0) },

   157     { "measureText", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionMeasureText), (intptr_t)1 THUNK_GENERATOR(0) },

   158     { "setAlpha", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetAlpha), (intptr_t)1 THUNK_GENERATOR(0) },

   159     { "setCompositeOperation", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetCompositeOperation), (intptr_t)1 THUNK_GENERATOR(0) },

   160     { "setLineWidth", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetLineWidth), (intptr_t)1 THUNK_GENERATOR(0) },

   161     { "setLineCap", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetLineCap), (intptr_t)1 THUNK_GENERATOR(0) },

   162     { "setLineJoin", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetLineJoin), (intptr_t)1 THUNK_GENERATOR(0) },

   163     { "setMiterLimit", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetMiterLimit), (intptr_t)1 THUNK_GENERATOR(0) },

   164     { "clearShadow", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionClearShadow), (intptr_t)0 THUNK_GENERATOR(0) },

   165     { "fillText", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionFillText), (intptr_t)0 THUNK_GENERATOR(0) },

   166     { "strokeText", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionStrokeText), (intptr_t)0 THUNK_GENERATOR(0) },

   167     { "setStrokeColor", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetStrokeColor), (intptr_t)0 THUNK_GENERATOR(0) },

   168     { "setFillColor", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetFillColor), (intptr_t)0 THUNK_GENERATOR(0) },

   169     { "strokeRect", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionStrokeRect), (intptr_t)0 THUNK_GENERATOR(0) },

   170     { "drawImage", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionDrawImage), (intptr_t)0 THUNK_GENERATOR(0) },

   171     { "drawImageFromRect", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionDrawImageFromRect), (intptr_t)0 THUNK_GENERATOR(0) },

   172     { "setShadow", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionSetShadow), (intptr_t)0 THUNK_GENERATOR(0) },

   173     { "createPattern", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionCreatePattern), (intptr_t)0 THUNK_GENERATOR(0) },

   174     { "putImageData", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionPutImageData), (intptr_t)0 THUNK_GENERATOR(0) },

   175     { "createImageData", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionCreateImageData), (intptr_t)0 THUNK_GENERATOR(0) },

   176     { "getImageData", DontDelete | Function, (intptr_t)static_cast<NativeFunction>(jsCanvasRenderingContext2DPrototypeFunctionGetImageData), (intptr_t)4 THUNK_GENERATOR(0) },

   177     { 0, 0, 0, 0 THUNK_GENERATOR(0) }

   178 };

   179 

   180 #undef THUNK_GENERATOR

   181 static JSC_CONST_HASHTABLE HashTable JSCanvasRenderingContext2DPrototypeTable = { 134, 127, JSCanvasRenderingContext2DPrototypeTableValues, 0 };

   182 const ClassInfo JSCanvasRenderingContext2DPrototype::s_info = { "CanvasRenderingContext2DPrototype", 0, &JSCanvasRenderingContext2DPrototypeTable, 0 };

   183 

   184 JSObject* JSCanvasRenderingContext2DPrototype::self(ExecState* exec, JSGlobalObject* globalObject)

   185 {

   186     return getDOMPrototype<JSCanvasRenderingContext2D>(exec, globalObject);

   187 }

   188 

   189 bool JSCanvasRenderingContext2DPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   190 {

   191     return getStaticFunctionSlot<JSObject>(exec, &JSCanvasRenderingContext2DPrototypeTable, this, propertyName, slot);

   192 }

   193 

   194 bool JSCanvasRenderingContext2DPrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   195 {

   196     return getStaticFunctionDescriptor<JSObject>(exec, &JSCanvasRenderingContext2DPrototypeTable, this, propertyName, descriptor);

   197 }

   198 

   199 const ClassInfo JSCanvasRenderingContext2D::s_info = { "CanvasRenderingContext2D", &JSCanvasRenderingContext::s_info, &JSCanvasRenderingContext2DTable, 0 };

   200 

   201 JSCanvasRenderingContext2D::JSCanvasRenderingContext2D(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<CanvasRenderingContext2D> impl)

   202     : JSCanvasRenderingContext(structure, globalObject, impl)

   203 {

   204 }

   205 

   206 JSObject* JSCanvasRenderingContext2D::createPrototype(ExecState* exec, JSGlobalObject* globalObject)

   207 {

   208     return new (exec) JSCanvasRenderingContext2DPrototype(globalObject, JSCanvasRenderingContext2DPrototype::createStructure(JSCanvasRenderingContextPrototype::self(exec, globalObject)));

   209 }

   210 

   211 bool JSCanvasRenderingContext2D::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)

   212 {

   213     return getStaticValueSlot<JSCanvasRenderingContext2D, Base>(exec, &JSCanvasRenderingContext2DTable, this, propertyName, slot);

   214 }

   215 

   216 bool JSCanvasRenderingContext2D::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)

   217 {

   218     return getStaticValueDescriptor<JSCanvasRenderingContext2D, Base>(exec, &JSCanvasRenderingContext2DTable, this, propertyName, descriptor);

   219 }

   220 

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

   222 {

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

   224     UNUSED_PARAM(exec);

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

   226     JSValue result = jsNumber(exec, imp->globalAlpha());

   227     return result;

   228 }

   229 

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

   231 {

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

   233     UNUSED_PARAM(exec);

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

   235     JSValue result = jsString(exec, imp->globalCompositeOperation());

   236     return result;

   237 }

   238 

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

   240 {

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

   242     UNUSED_PARAM(exec);

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

   244     JSValue result = jsNumber(exec, imp->lineWidth());

   245     return result;

   246 }

   247 

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

   249 {

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

   251     UNUSED_PARAM(exec);

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

   253     JSValue result = jsString(exec, imp->lineCap());

   254     return result;

   255 }

   256 

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

   258 {

   259     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(slotBase));

   260     UNUSED_PARAM(exec);

   261     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   262     JSValue result = jsString(exec, imp->lineJoin());

   263     return result;

   264 }

   265 

   266 JSValue jsCanvasRenderingContext2DMiterLimit(ExecState* exec, JSValue slotBase, const Identifier&)

   267 {

   268     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(slotBase));

   269     UNUSED_PARAM(exec);

   270     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   271     JSValue result = jsNumber(exec, imp->miterLimit());

   272     return result;

   273 }

   274 

   275 JSValue jsCanvasRenderingContext2DShadowOffsetX(ExecState* exec, JSValue slotBase, const Identifier&)

   276 {

   277     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(slotBase));

   278     UNUSED_PARAM(exec);

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

   280     JSValue result = jsNumber(exec, imp->shadowOffsetX());

   281     return result;

   282 }

   283 

   284 JSValue jsCanvasRenderingContext2DShadowOffsetY(ExecState* exec, JSValue slotBase, const Identifier&)

   285 {

   286     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(slotBase));

   287     UNUSED_PARAM(exec);

   288     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   289     JSValue result = jsNumber(exec, imp->shadowOffsetY());

   290     return result;

   291 }

   292 

   293 JSValue jsCanvasRenderingContext2DShadowBlur(ExecState* exec, JSValue slotBase, const Identifier&)

   294 {

   295     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(slotBase));

   296     UNUSED_PARAM(exec);

   297     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   298     JSValue result = jsNumber(exec, imp->shadowBlur());

   299     return result;

   300 }

   301 

   302 JSValue jsCanvasRenderingContext2DShadowColor(ExecState* exec, JSValue slotBase, const Identifier&)

   303 {

   304     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(slotBase));

   305     UNUSED_PARAM(exec);

   306     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   307     JSValue result = jsString(exec, imp->shadowColor());

   308     return result;

   309 }

   310 

   311 JSValue jsCanvasRenderingContext2DFont(ExecState* exec, JSValue slotBase, const Identifier&)

   312 {

   313     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(slotBase));

   314     UNUSED_PARAM(exec);

   315     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   316     JSValue result = jsString(exec, imp->font());

   317     return result;

   318 }

   319 

   320 JSValue jsCanvasRenderingContext2DTextAlign(ExecState* exec, JSValue slotBase, const Identifier&)

   321 {

   322     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(slotBase));

   323     UNUSED_PARAM(exec);

   324     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   325     JSValue result = jsString(exec, imp->textAlign());

   326     return result;

   327 }

   328 

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

   330 {

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

   332     UNUSED_PARAM(exec);

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

   334     JSValue result = jsString(exec, imp->textBaseline());

   335     return result;

   336 }

   337 

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

   339 {

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

   341     return castedThis->strokeStyle(exec);

   342 }

   343 

   344 JSValue jsCanvasRenderingContext2DFillStyle(ExecState* exec, JSValue slotBase, const Identifier&)

   345 {

   346     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(slotBase));

   347     return castedThis->fillStyle(exec);

   348 }

   349 

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

   351 {

   352     JSCanvasRenderingContext2D* domObject = static_cast<JSCanvasRenderingContext2D*>(asObject(slotBase));

   353     return JSCanvasRenderingContext2D::getConstructor(exec, domObject->globalObject());

   354 }

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

   356 {

   357     lookupPut<JSCanvasRenderingContext2D, Base>(exec, propertyName, value, &JSCanvasRenderingContext2DTable, this, slot);

   358 }

   359 

   360 void setJSCanvasRenderingContext2DGlobalAlpha(ExecState* exec, JSObject* thisObject, JSValue value)

   361 {

   362     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

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

   364     imp->setGlobalAlpha(value.toFloat(exec));

   365 }

   366 

   367 void setJSCanvasRenderingContext2DGlobalCompositeOperation(ExecState* exec, JSObject* thisObject, JSValue value)

   368 {

   369     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   370     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   371     imp->setGlobalCompositeOperation(valueToStringWithNullCheck(exec, value));

   372 }

   373 

   374 void setJSCanvasRenderingContext2DLineWidth(ExecState* exec, JSObject* thisObject, JSValue value)

   375 {

   376     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   377     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   378     imp->setLineWidth(value.toFloat(exec));

   379 }

   380 

   381 void setJSCanvasRenderingContext2DLineCap(ExecState* exec, JSObject* thisObject, JSValue value)

   382 {

   383     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   384     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   385     imp->setLineCap(valueToStringWithNullCheck(exec, value));

   386 }

   387 

   388 void setJSCanvasRenderingContext2DLineJoin(ExecState* exec, JSObject* thisObject, JSValue value)

   389 {

   390     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   391     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   392     imp->setLineJoin(valueToStringWithNullCheck(exec, value));

   393 }

   394 

   395 void setJSCanvasRenderingContext2DMiterLimit(ExecState* exec, JSObject* thisObject, JSValue value)

   396 {

   397     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   398     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   399     imp->setMiterLimit(value.toFloat(exec));

   400 }

   401 

   402 void setJSCanvasRenderingContext2DShadowOffsetX(ExecState* exec, JSObject* thisObject, JSValue value)

   403 {

   404     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   405     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   406     imp->setShadowOffsetX(value.toFloat(exec));

   407 }

   408 

   409 void setJSCanvasRenderingContext2DShadowOffsetY(ExecState* exec, JSObject* thisObject, JSValue value)

   410 {

   411     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   412     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   413     imp->setShadowOffsetY(value.toFloat(exec));

   414 }

   415 

   416 void setJSCanvasRenderingContext2DShadowBlur(ExecState* exec, JSObject* thisObject, JSValue value)

   417 {

   418     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   419     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   420     imp->setShadowBlur(value.toFloat(exec));

   421 }

   422 

   423 void setJSCanvasRenderingContext2DShadowColor(ExecState* exec, JSObject* thisObject, JSValue value)

   424 {

   425     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

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

   427     imp->setShadowColor(valueToStringWithNullCheck(exec, value));

   428 }

   429 

   430 void setJSCanvasRenderingContext2DFont(ExecState* exec, JSObject* thisObject, JSValue value)

   431 {

   432     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   433     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   434     imp->setFont(ustringToString(value.toString(exec)));

   435 }

   436 

   437 void setJSCanvasRenderingContext2DTextAlign(ExecState* exec, JSObject* thisObject, JSValue value)

   438 {

   439     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   440     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   441     imp->setTextAlign(ustringToString(value.toString(exec)));

   442 }

   443 

   444 void setJSCanvasRenderingContext2DTextBaseline(ExecState* exec, JSObject* thisObject, JSValue value)

   445 {

   446     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(thisObject);

   447     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   448     imp->setTextBaseline(ustringToString(value.toString(exec)));

   449 }

   450 

   451 void setJSCanvasRenderingContext2DStrokeStyle(ExecState* exec, JSObject* thisObject, JSValue value)

   452 {

   453     static_cast<JSCanvasRenderingContext2D*>(thisObject)->setStrokeStyle(exec, value);

   454 }

   455 

   456 void setJSCanvasRenderingContext2DFillStyle(ExecState* exec, JSObject* thisObject, JSValue value)

   457 {

   458     static_cast<JSCanvasRenderingContext2D*>(thisObject)->setFillStyle(exec, value);

   459 }

   460 

   461 JSValue JSCanvasRenderingContext2D::getConstructor(ExecState* exec, JSGlobalObject* globalObject)

   462 {

   463     return getDOMConstructor<JSCanvasRenderingContext2DConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));

   464 }

   465 

   466 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSave(ExecState* exec)

   467 {

   468     JSValue thisValue = exec->hostThisValue();

   469     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   470         return throwVMTypeError(exec);

   471     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   472     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   473 

   474     imp->save();

   475     return JSValue::encode(jsUndefined());

   476 }

   477 

   478 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionRestore(ExecState* exec)

   479 {

   480     JSValue thisValue = exec->hostThisValue();

   481     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   482         return throwVMTypeError(exec);

   483     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   484     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   485 

   486     imp->restore();

   487     return JSValue::encode(jsUndefined());

   488 }

   489 

   490 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionScale(ExecState* exec)

   491 {

   492     JSValue thisValue = exec->hostThisValue();

   493     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   494         return throwVMTypeError(exec);

   495     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   496     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   497     float sx = exec->argument(0).toFloat(exec);

   498     float sy = exec->argument(1).toFloat(exec);

   499 

   500     imp->scale(sx, sy);

   501     return JSValue::encode(jsUndefined());

   502 }

   503 

   504 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionRotate(ExecState* exec)

   505 {

   506     JSValue thisValue = exec->hostThisValue();

   507     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   508         return throwVMTypeError(exec);

   509     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   510     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   511     float angle = exec->argument(0).toFloat(exec);

   512 

   513     imp->rotate(angle);

   514     return JSValue::encode(jsUndefined());

   515 }

   516 

   517 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionTranslate(ExecState* exec)

   518 {

   519     JSValue thisValue = exec->hostThisValue();

   520     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   521         return throwVMTypeError(exec);

   522     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   523     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   524     float tx = exec->argument(0).toFloat(exec);

   525     float ty = exec->argument(1).toFloat(exec);

   526 

   527     imp->translate(tx, ty);

   528     return JSValue::encode(jsUndefined());

   529 }

   530 

   531 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionTransform(ExecState* exec)

   532 {

   533     JSValue thisValue = exec->hostThisValue();

   534     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   535         return throwVMTypeError(exec);

   536     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   537     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   538     float m11 = exec->argument(0).toFloat(exec);

   539     float m12 = exec->argument(1).toFloat(exec);

   540     float m21 = exec->argument(2).toFloat(exec);

   541     float m22 = exec->argument(3).toFloat(exec);

   542     float dx = exec->argument(4).toFloat(exec);

   543     float dy = exec->argument(5).toFloat(exec);

   544 

   545     imp->transform(m11, m12, m21, m22, dx, dy);

   546     return JSValue::encode(jsUndefined());

   547 }

   548 

   549 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSetTransform(ExecState* exec)

   550 {

   551     JSValue thisValue = exec->hostThisValue();

   552     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   553         return throwVMTypeError(exec);

   554     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   555     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   556     float m11 = exec->argument(0).toFloat(exec);

   557     float m12 = exec->argument(1).toFloat(exec);

   558     float m21 = exec->argument(2).toFloat(exec);

   559     float m22 = exec->argument(3).toFloat(exec);

   560     float dx = exec->argument(4).toFloat(exec);

   561     float dy = exec->argument(5).toFloat(exec);

   562 

   563     imp->setTransform(m11, m12, m21, m22, dx, dy);

   564     return JSValue::encode(jsUndefined());

   565 }

   566 

   567 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionCreateLinearGradient(ExecState* exec)

   568 {

   569     JSValue thisValue = exec->hostThisValue();

   570     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   571         return throwVMTypeError(exec);

   572     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   573     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   574     ExceptionCode ec = 0;

   575     float x0 = exec->argument(0).toFloat(exec);

   576     float y0 = exec->argument(1).toFloat(exec);

   577     float x1 = exec->argument(2).toFloat(exec);

   578     float y1 = exec->argument(3).toFloat(exec);

   579 

   580 

   581     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createLinearGradient(x0, y0, x1, y1, ec)));

   582     setDOMException(exec, ec);

   583     return JSValue::encode(result);

   584 }

   585 

   586 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionCreateRadialGradient(ExecState* exec)

   587 {

   588     JSValue thisValue = exec->hostThisValue();

   589     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   590         return throwVMTypeError(exec);

   591     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   592     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   593     ExceptionCode ec = 0;

   594     float x0 = exec->argument(0).toFloat(exec);

   595     float y0 = exec->argument(1).toFloat(exec);

   596     float r0 = exec->argument(2).toFloat(exec);

   597     float x1 = exec->argument(3).toFloat(exec);

   598     float y1 = exec->argument(4).toFloat(exec);

   599     float r1 = exec->argument(5).toFloat(exec);

   600 

   601 

   602     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->createRadialGradient(x0, y0, r0, x1, y1, r1, ec)));

   603     setDOMException(exec, ec);

   604     return JSValue::encode(result);

   605 }

   606 

   607 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionClearRect(ExecState* exec)

   608 {

   609     JSValue thisValue = exec->hostThisValue();

   610     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   611         return throwVMTypeError(exec);

   612     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   613     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   614     float x = exec->argument(0).toFloat(exec);

   615     float y = exec->argument(1).toFloat(exec);

   616     float width = exec->argument(2).toFloat(exec);

   617     float height = exec->argument(3).toFloat(exec);

   618 

   619     imp->clearRect(x, y, width, height);

   620     return JSValue::encode(jsUndefined());

   621 }

   622 

   623 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionFillRect(ExecState* exec)

   624 {

   625     JSValue thisValue = exec->hostThisValue();

   626     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   627         return throwVMTypeError(exec);

   628     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   629     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   630     float x = exec->argument(0).toFloat(exec);

   631     float y = exec->argument(1).toFloat(exec);

   632     float width = exec->argument(2).toFloat(exec);

   633     float height = exec->argument(3).toFloat(exec);

   634 

   635     imp->fillRect(x, y, width, height);

   636     return JSValue::encode(jsUndefined());

   637 }

   638 

   639 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionBeginPath(ExecState* exec)

   640 {

   641     JSValue thisValue = exec->hostThisValue();

   642     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   643         return throwVMTypeError(exec);

   644     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   645     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   646 

   647     imp->beginPath();

   648     return JSValue::encode(jsUndefined());

   649 }

   650 

   651 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionClosePath(ExecState* exec)

   652 {

   653     JSValue thisValue = exec->hostThisValue();

   654     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   655         return throwVMTypeError(exec);

   656     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   657     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   658 

   659     imp->closePath();

   660     return JSValue::encode(jsUndefined());

   661 }

   662 

   663 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionMoveTo(ExecState* exec)

   664 {

   665     JSValue thisValue = exec->hostThisValue();

   666     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   667         return throwVMTypeError(exec);

   668     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   669     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   670     float x = exec->argument(0).toFloat(exec);

   671     float y = exec->argument(1).toFloat(exec);

   672 

   673     imp->moveTo(x, y);

   674     return JSValue::encode(jsUndefined());

   675 }

   676 

   677 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionLineTo(ExecState* exec)

   678 {

   679     JSValue thisValue = exec->hostThisValue();

   680     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   681         return throwVMTypeError(exec);

   682     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   683     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   684     float x = exec->argument(0).toFloat(exec);

   685     float y = exec->argument(1).toFloat(exec);

   686 

   687     imp->lineTo(x, y);

   688     return JSValue::encode(jsUndefined());

   689 }

   690 

   691 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionQuadraticCurveTo(ExecState* exec)

   692 {

   693     JSValue thisValue = exec->hostThisValue();

   694     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   695         return throwVMTypeError(exec);

   696     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   697     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   698     float cpx = exec->argument(0).toFloat(exec);

   699     float cpy = exec->argument(1).toFloat(exec);

   700     float x = exec->argument(2).toFloat(exec);

   701     float y = exec->argument(3).toFloat(exec);

   702 

   703     imp->quadraticCurveTo(cpx, cpy, x, y);

   704     return JSValue::encode(jsUndefined());

   705 }

   706 

   707 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionBezierCurveTo(ExecState* exec)

   708 {

   709     JSValue thisValue = exec->hostThisValue();

   710     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   711         return throwVMTypeError(exec);

   712     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   713     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   714     float cp1x = exec->argument(0).toFloat(exec);

   715     float cp1y = exec->argument(1).toFloat(exec);

   716     float cp2x = exec->argument(2).toFloat(exec);

   717     float cp2y = exec->argument(3).toFloat(exec);

   718     float x = exec->argument(4).toFloat(exec);

   719     float y = exec->argument(5).toFloat(exec);

   720 

   721     imp->bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);

   722     return JSValue::encode(jsUndefined());

   723 }

   724 

   725 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionArcTo(ExecState* exec)

   726 {

   727     JSValue thisValue = exec->hostThisValue();

   728     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   729         return throwVMTypeError(exec);

   730     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   731     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   732     ExceptionCode ec = 0;

   733     float x1 = exec->argument(0).toFloat(exec);

   734     float y1 = exec->argument(1).toFloat(exec);

   735     float x2 = exec->argument(2).toFloat(exec);

   736     float y2 = exec->argument(3).toFloat(exec);

   737     float radius = exec->argument(4).toFloat(exec);

   738 

   739     imp->arcTo(x1, y1, x2, y2, radius, ec);

   740     setDOMException(exec, ec);

   741     return JSValue::encode(jsUndefined());

   742 }

   743 

   744 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionRect(ExecState* exec)

   745 {

   746     JSValue thisValue = exec->hostThisValue();

   747     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   748         return throwVMTypeError(exec);

   749     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   750     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   751     float x = exec->argument(0).toFloat(exec);

   752     float y = exec->argument(1).toFloat(exec);

   753     float width = exec->argument(2).toFloat(exec);

   754     float height = exec->argument(3).toFloat(exec);

   755 

   756     imp->rect(x, y, width, height);

   757     return JSValue::encode(jsUndefined());

   758 }

   759 

   760 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionArc(ExecState* exec)

   761 {

   762     JSValue thisValue = exec->hostThisValue();

   763     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   764         return throwVMTypeError(exec);

   765     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   766     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   767     ExceptionCode ec = 0;

   768     float x = exec->argument(0).toFloat(exec);

   769     float y = exec->argument(1).toFloat(exec);

   770     float radius = exec->argument(2).toFloat(exec);

   771     float startAngle = exec->argument(3).toFloat(exec);

   772     float endAngle = exec->argument(4).toFloat(exec);

   773     bool anticlockwise = exec->argument(5).toBoolean(exec);

   774 

   775     imp->arc(x, y, radius, startAngle, endAngle, anticlockwise, ec);

   776     setDOMException(exec, ec);

   777     return JSValue::encode(jsUndefined());

   778 }

   779 

   780 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionFill(ExecState* exec)

   781 {

   782     JSValue thisValue = exec->hostThisValue();

   783     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   784         return throwVMTypeError(exec);

   785     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   786     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   787 

   788     imp->fill();

   789     return JSValue::encode(jsUndefined());

   790 }

   791 

   792 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionStroke(ExecState* exec)

   793 {

   794     JSValue thisValue = exec->hostThisValue();

   795     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   796         return throwVMTypeError(exec);

   797     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

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

   799 

   800     imp->stroke();

   801     return JSValue::encode(jsUndefined());

   802 }

   803 

   804 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionClip(ExecState* exec)

   805 {

   806     JSValue thisValue = exec->hostThisValue();

   807     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   808         return throwVMTypeError(exec);

   809     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   810     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   811 

   812     imp->clip();

   813     return JSValue::encode(jsUndefined());

   814 }

   815 

   816 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionIsPointInPath(ExecState* exec)

   817 {

   818     JSValue thisValue = exec->hostThisValue();

   819     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   820         return throwVMTypeError(exec);

   821     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   822     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   823     float x = exec->argument(0).toFloat(exec);

   824     float y = exec->argument(1).toFloat(exec);

   825 

   826 

   827     JSC::JSValue result = jsBoolean(imp->isPointInPath(x, y));

   828     return JSValue::encode(result);

   829 }

   830 

   831 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionMeasureText(ExecState* exec)

   832 {

   833     JSValue thisValue = exec->hostThisValue();

   834     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   835         return throwVMTypeError(exec);

   836     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   837     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   838     const String& text = ustringToString(exec->argument(0).toString(exec));

   839 

   840 

   841     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->measureText(text)));

   842     return JSValue::encode(result);

   843 }

   844 

   845 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSetAlpha(ExecState* exec)

   846 {

   847     JSValue thisValue = exec->hostThisValue();

   848     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   849         return throwVMTypeError(exec);

   850     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   851     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   852     float alpha = exec->argument(0).toFloat(exec);

   853 

   854     imp->setAlpha(alpha);

   855     return JSValue::encode(jsUndefined());

   856 }

   857 

   858 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSetCompositeOperation(ExecState* exec)

   859 {

   860     JSValue thisValue = exec->hostThisValue();

   861     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   862         return throwVMTypeError(exec);

   863     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   864     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   865     const String& compositeOperation = ustringToString(exec->argument(0).toString(exec));

   866 

   867     imp->setCompositeOperation(compositeOperation);

   868     return JSValue::encode(jsUndefined());

   869 }

   870 

   871 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSetLineWidth(ExecState* exec)

   872 {

   873     JSValue thisValue = exec->hostThisValue();

   874     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   875         return throwVMTypeError(exec);

   876     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   877     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   878     float width = exec->argument(0).toFloat(exec);

   879 

   880     imp->setLineWidth(width);

   881     return JSValue::encode(jsUndefined());

   882 }

   883 

   884 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSetLineCap(ExecState* exec)

   885 {

   886     JSValue thisValue = exec->hostThisValue();

   887     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   888         return throwVMTypeError(exec);

   889     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   890     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   891     const String& cap = ustringToString(exec->argument(0).toString(exec));

   892 

   893     imp->setLineCap(cap);

   894     return JSValue::encode(jsUndefined());

   895 }

   896 

   897 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSetLineJoin(ExecState* exec)

   898 {

   899     JSValue thisValue = exec->hostThisValue();

   900     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   901         return throwVMTypeError(exec);

   902     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   903     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   904     const String& join = ustringToString(exec->argument(0).toString(exec));

   905 

   906     imp->setLineJoin(join);

   907     return JSValue::encode(jsUndefined());

   908 }

   909 

   910 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSetMiterLimit(ExecState* exec)

   911 {

   912     JSValue thisValue = exec->hostThisValue();

   913     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   914         return throwVMTypeError(exec);

   915     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   916     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   917     float limit = exec->argument(0).toFloat(exec);

   918 

   919     imp->setMiterLimit(limit);

   920     return JSValue::encode(jsUndefined());

   921 }

   922 

   923 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionClearShadow(ExecState* exec)

   924 {

   925     JSValue thisValue = exec->hostThisValue();

   926     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   927         return throwVMTypeError(exec);

   928     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   929     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

   930 

   931     imp->clearShadow();

   932     return JSValue::encode(jsUndefined());

   933 }

   934 

   935 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionFillText(ExecState* exec)

   936 {

   937     JSValue thisValue = exec->hostThisValue();

   938     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   939         return throwVMTypeError(exec);

   940     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   941     return JSValue::encode(castedThis->fillText(exec));

   942 }

   943 

   944 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionStrokeText(ExecState* exec)

   945 {

   946     JSValue thisValue = exec->hostThisValue();

   947     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   948         return throwVMTypeError(exec);

   949     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   950     return JSValue::encode(castedThis->strokeText(exec));

   951 }

   952 

   953 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSetStrokeColor(ExecState* exec)

   954 {

   955     JSValue thisValue = exec->hostThisValue();

   956     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   957         return throwVMTypeError(exec);

   958     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   959     return JSValue::encode(castedThis->setStrokeColor(exec));

   960 }

   961 

   962 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSetFillColor(ExecState* exec)

   963 {

   964     JSValue thisValue = exec->hostThisValue();

   965     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   966         return throwVMTypeError(exec);

   967     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   968     return JSValue::encode(castedThis->setFillColor(exec));

   969 }

   970 

   971 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionStrokeRect(ExecState* exec)

   972 {

   973     JSValue thisValue = exec->hostThisValue();

   974     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   975         return throwVMTypeError(exec);

   976     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   977     return JSValue::encode(castedThis->strokeRect(exec));

   978 }

   979 

   980 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionDrawImage(ExecState* exec)

   981 {

   982     JSValue thisValue = exec->hostThisValue();

   983     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   984         return throwVMTypeError(exec);

   985     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   986     return JSValue::encode(castedThis->drawImage(exec));

   987 }

   988 

   989 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionDrawImageFromRect(ExecState* exec)

   990 {

   991     JSValue thisValue = exec->hostThisValue();

   992     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

   993         return throwVMTypeError(exec);

   994     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

   995     return JSValue::encode(castedThis->drawImageFromRect(exec));

   996 }

   997 

   998 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionSetShadow(ExecState* exec)

   999 {

  1000     JSValue thisValue = exec->hostThisValue();

  1001     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

  1002         return throwVMTypeError(exec);

  1003     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

  1004     return JSValue::encode(castedThis->setShadow(exec));

  1005 }

  1006 

  1007 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionCreatePattern(ExecState* exec)

  1008 {

  1009     JSValue thisValue = exec->hostThisValue();

  1010     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

  1011         return throwVMTypeError(exec);

  1012     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

  1013     return JSValue::encode(castedThis->createPattern(exec));

  1014 }

  1015 

  1016 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionPutImageData(ExecState* exec)

  1017 {

  1018     JSValue thisValue = exec->hostThisValue();

  1019     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

  1020         return throwVMTypeError(exec);

  1021     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

  1022     return JSValue::encode(castedThis->putImageData(exec));

  1023 }

  1024 

  1025 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionCreateImageData(ExecState* exec)

  1026 {

  1027     JSValue thisValue = exec->hostThisValue();

  1028     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

  1029         return throwVMTypeError(exec);

  1030     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

  1031     return JSValue::encode(castedThis->createImageData(exec));

  1032 }

  1033 

  1034 EncodedJSValue JSC_HOST_CALL jsCanvasRenderingContext2DPrototypeFunctionGetImageData(ExecState* exec)

  1035 {

  1036     JSValue thisValue = exec->hostThisValue();

  1037     if (!thisValue.inherits(&JSCanvasRenderingContext2D::s_info))

  1038         return throwVMTypeError(exec);

  1039     JSCanvasRenderingContext2D* castedThis = static_cast<JSCanvasRenderingContext2D*>(asObject(thisValue));

  1040     CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(castedThis->impl());

  1041     ExceptionCode ec = 0;

  1042     float sx = exec->argument(0).toFloat(exec);

  1043     float sy = exec->argument(1).toFloat(exec);

  1044     float sw = exec->argument(2).toFloat(exec);

  1045     float sh = exec->argument(3).toFloat(exec);

  1046 

  1047 

  1048     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->getImageData(sx, sy, sw, sh, ec)));

  1049     setDOMException(exec, ec);

  1050     return JSValue::encode(result);

  1051 }

  1052 

  1053 

  1054 }