1 /*

     2     This file is part of the WebKit open source project.

     3     This file has been generated by generate-bindings.pl. DO NOT MODIFY!

     4 

     5     This library is free software; you can redistribute it and/or

     6     modify it under the terms of the GNU Library General Public

     7     License as published by the Free Software Foundation; either

     8     version 2 of the License, or (at your option) any later version.

     9 

    10     This library is distributed in the hope that it will be useful,

    11     but WITHOUT ANY WARRANTY; without even the implied warranty of

    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13     Library General Public License for more details.

    14 

    15     You should have received a copy of the GNU Library General Public License

    16     along with this library; see the file COPYING.LIB.  If not, write to

    17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    18     Boston, MA 02110-1301, USA.

    19 */

    20 

    21 #include "config.h"

    22 

    23 #include "JSCanvasRenderingContext2D.h"

    24 

    25 #include <wtf/GetPtr.h>

    26 

    27 #include "CanvasGradient.h"

    28 #include "CanvasPattern.h"

    29 #include "CanvasRenderingContext2D.h"

    30 #include "CanvasStyle.h"

    31 #include "HTMLCanvasElement.h"

    32 #include "JSCanvasGradient.h"

    33 #include "JSHTMLCanvasElement.h"

    34 #include "PlatformString.h"

    35 

    36 using namespace KJS;

    37 

    38 namespace WebCore {

    39 

    40 /* Hash table */

    41 

    42 static const HashEntry JSCanvasRenderingContext2DTableEntries[] =

    43 {

    44     { "lineWidth", JSCanvasRenderingContext2D::LineWidthAttrNum, DontDelete, 0, &JSCanvasRenderingContext2DTableEntries[14] },

    45     { "shadowOffsetY", JSCanvasRenderingContext2D::ShadowOffsetYAttrNum, DontDelete, 0, 0 },

    46     { 0, 0, 0, 0, 0 },

    47     { "strokeStyle", JSCanvasRenderingContext2D::StrokeStyleAttrNum, DontDelete, 0, 0 },

    48     { "globalAlpha", JSCanvasRenderingContext2D::GlobalAlphaAttrNum, DontDelete, 0, 0 },

    49     { "lineJoin", JSCanvasRenderingContext2D::LineJoinAttrNum, DontDelete, 0, 0 },

    50     { 0, 0, 0, 0, 0 },

    51     { "shadowOffsetX", JSCanvasRenderingContext2D::ShadowOffsetXAttrNum, DontDelete, 0, 0 },

    52     { "globalCompositeOperation", JSCanvasRenderingContext2D::GlobalCompositeOperationAttrNum, DontDelete, 0, 0 },

    53     { "lineCap", JSCanvasRenderingContext2D::LineCapAttrNum, DontDelete, 0, 0 },

    54     { "shadowColor", JSCanvasRenderingContext2D::ShadowColorAttrNum, DontDelete, 0, 0 },

    55     { "canvas", JSCanvasRenderingContext2D::CanvasAttrNum, DontDelete|ReadOnly, 0, &JSCanvasRenderingContext2DTableEntries[13] },

    56     { "shadowBlur", JSCanvasRenderingContext2D::ShadowBlurAttrNum, DontDelete, 0, 0 },

    57     { "miterLimit", JSCanvasRenderingContext2D::MiterLimitAttrNum, DontDelete, 0, 0 },

    58     { "fillStyle", JSCanvasRenderingContext2D::FillStyleAttrNum, DontDelete, 0, 0 }

    59 };

    60 

    61 static const HashTable JSCanvasRenderingContext2DTable = 

    62 {

    63     2, 15, JSCanvasRenderingContext2DTableEntries, 13

    64 };

    65 

    66 /* Hash table for prototype */

    67 

    68 static const HashEntry JSCanvasRenderingContext2DPrototypeTableEntries[] =

    69 {

    70     { "fill", JSCanvasRenderingContext2D::FillFuncNum, DontDelete|Function, 0, 0 },

    71     { "lineTo", JSCanvasRenderingContext2D::LineToFuncNum, DontDelete|Function, 2, &JSCanvasRenderingContext2DPrototypeTableEntries[41] },

    72     { 0, 0, 0, 0, 0 },

    73     { "save", JSCanvasRenderingContext2D::SaveFuncNum, DontDelete|Function, 0, &JSCanvasRenderingContext2DPrototypeTableEntries[36] },

    74     { 0, 0, 0, 0, 0 },

    75     { "restore", JSCanvasRenderingContext2D::RestoreFuncNum, DontDelete|Function, 0, &JSCanvasRenderingContext2DPrototypeTableEntries[46] },

    76     { "drawImageFromRect", JSCanvasRenderingContext2D::DrawImageFromRectFuncNum, DontDelete|Function, 0, 0 },

    77     { 0, 0, 0, 0, 0 },

    78     { "setLineJoin", JSCanvasRenderingContext2D::SetLineJoinFuncNum, DontDelete|Function, 1, 0 },

    79     { 0, 0, 0, 0, 0 },

    80     { "createLinearGradient", JSCanvasRenderingContext2D::CreateLinearGradientFuncNum, DontDelete|Function, 4, &JSCanvasRenderingContext2DPrototypeTableEntries[35] },

    81     { "setShadow", JSCanvasRenderingContext2D::SetShadowFuncNum, DontDelete|Function, 0, 0 },

    82     { 0, 0, 0, 0, 0 },

    83     { "clip", JSCanvasRenderingContext2D::ClipFuncNum, DontDelete|Function, 0, &JSCanvasRenderingContext2DPrototypeTableEntries[43] },

    84     { "rotate", JSCanvasRenderingContext2D::RotateFuncNum, DontDelete|Function, 1, &JSCanvasRenderingContext2DPrototypeTableEntries[38] },

    85     { "setLineWidth", JSCanvasRenderingContext2D::SetLineWidthFuncNum, DontDelete|Function, 1, 0 },

    86     { 0, 0, 0, 0, 0 },

    87     { "translate", JSCanvasRenderingContext2D::TranslateFuncNum, DontDelete|Function, 2, &JSCanvasRenderingContext2DPrototypeTableEntries[45] },

    88     { "setFillColor", JSCanvasRenderingContext2D::SetFillColorFuncNum, DontDelete|Function, 0, 0 },

    89     { 0, 0, 0, 0, 0 },

    90     { "createPattern", JSCanvasRenderingContext2D::CreatePatternFuncNum, DontDelete|Function, 0, 0 },

    91     { "quadraticCurveTo", JSCanvasRenderingContext2D::QuadraticCurveToFuncNum, DontDelete|Function, 4, 0 },

    92     { 0, 0, 0, 0, 0 },

    93     { "scale", JSCanvasRenderingContext2D::ScaleFuncNum, DontDelete|Function, 2, 0 },

    94     { "setCompositeOperation", JSCanvasRenderingContext2D::SetCompositeOperationFuncNum, DontDelete|Function, 1, &JSCanvasRenderingContext2DPrototypeTableEntries[44] },

    95     { 0, 0, 0, 0, 0 },

    96     { "beginPath", JSCanvasRenderingContext2D::BeginPathFuncNum, DontDelete|Function, 0, 0 },

    97     { 0, 0, 0, 0, 0 },

    98     { "bezierCurveTo", JSCanvasRenderingContext2D::BezierCurveToFuncNum, DontDelete|Function, 6, 0 },

    99     { 0, 0, 0, 0, 0 },

   100     { "moveTo", JSCanvasRenderingContext2D::MoveToFuncNum, DontDelete|Function, 2, &JSCanvasRenderingContext2DPrototypeTableEntries[42] },

   101     { "clearRect", JSCanvasRenderingContext2D::ClearRectFuncNum, DontDelete|Function, 4, &JSCanvasRenderingContext2DPrototypeTableEntries[40] },

   102     { 0, 0, 0, 0, 0 },

   103     { "arc", JSCanvasRenderingContext2D::ArcFuncNum, DontDelete|Function, 6, 0 },

   104     { "createRadialGradient", JSCanvasRenderingContext2D::CreateRadialGradientFuncNum, DontDelete|Function, 6, 0 },

   105     { "fillRect", JSCanvasRenderingContext2D::FillRectFuncNum, DontDelete|Function, 4, &JSCanvasRenderingContext2DPrototypeTableEntries[37] },

   106     { "closePath", JSCanvasRenderingContext2D::ClosePathFuncNum, DontDelete|Function, 0, 0 },

   107     { "arcTo", JSCanvasRenderingContext2D::ArcToFuncNum, DontDelete|Function, 5, &JSCanvasRenderingContext2DPrototypeTableEntries[39] },

   108     { "rect", JSCanvasRenderingContext2D::RectFuncNum, DontDelete|Function, 4, 0 },

   109     { "stroke", JSCanvasRenderingContext2D::StrokeFuncNum, DontDelete|Function, 0, 0 },

   110     { "setAlpha", JSCanvasRenderingContext2D::SetAlphaFuncNum, DontDelete|Function, 1, 0 },

   111     { "setLineCap", JSCanvasRenderingContext2D::SetLineCapFuncNum, DontDelete|Function, 1, 0 },

   112     { "setMiterLimit", JSCanvasRenderingContext2D::SetMiterLimitFuncNum, DontDelete|Function, 1, 0 },

   113     { "clearShadow", JSCanvasRenderingContext2D::ClearShadowFuncNum, DontDelete|Function, 0, 0 },

   114     { "setStrokeColor", JSCanvasRenderingContext2D::SetStrokeColorFuncNum, DontDelete|Function, 0, 0 },

   115     { "strokeRect", JSCanvasRenderingContext2D::StrokeRectFuncNum, DontDelete|Function, 0, 0 },

   116     { "drawImage", JSCanvasRenderingContext2D::DrawImageFuncNum, DontDelete|Function, 0, 0 }

   117 };

   118 

   119 static const HashTable JSCanvasRenderingContext2DPrototypeTable = 

   120 {

   121     2, 47, JSCanvasRenderingContext2DPrototypeTableEntries, 35

   122 };

   123 

   124 const ClassInfo JSCanvasRenderingContext2DPrototype::info = { "CanvasRenderingContext2DPrototype", 0, &JSCanvasRenderingContext2DPrototypeTable, 0 };

   125 

   126 JSObject* JSCanvasRenderingContext2DPrototype::self(ExecState* exec)

   127 {

   128     return KJS::cacheGlobalObject<JSCanvasRenderingContext2DPrototype>(exec, "[[JSCanvasRenderingContext2D.prototype]]");

   129 }

   130 

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

   132 {

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

   134 }

   135 

   136 const ClassInfo JSCanvasRenderingContext2D::info = { "CanvasRenderingContext2D", 0, &JSCanvasRenderingContext2DTable, 0 };

   137 

   138 JSCanvasRenderingContext2D::JSCanvasRenderingContext2D(ExecState* exec, CanvasRenderingContext2D* impl)

   139     : m_impl(impl)

   140 {

   141     setPrototype(JSCanvasRenderingContext2DPrototype::self(exec));

   142 }

   143 

   144 JSCanvasRenderingContext2D::~JSCanvasRenderingContext2D()

   145 {

   146     ScriptInterpreter::forgetDOMObject(m_impl.get());

   147 }

   148 

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

   150 {

   151     return getStaticValueSlot<JSCanvasRenderingContext2D, KJS::DOMObject>(exec, &JSCanvasRenderingContext2DTable, this, propertyName, slot);

   152 }

   153 

   154 JSValue* JSCanvasRenderingContext2D::getValueProperty(ExecState* exec, int token) const

   155 {

   156     switch (token) {

   157     case CanvasAttrNum: {

   158         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   159 

   160         return toJS(exec, WTF::getPtr(imp->canvas()));

   161     }

   162     case GlobalAlphaAttrNum: {

   163         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   164 

   165         return jsNumber(imp->globalAlpha());

   166     }

   167     case GlobalCompositeOperationAttrNum: {

   168         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   169 

   170         return jsString(imp->globalCompositeOperation());

   171     }

   172     case LineWidthAttrNum: {

   173         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   174 

   175         return jsNumber(imp->lineWidth());

   176     }

   177     case LineCapAttrNum: {

   178         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   179 

   180         return jsString(imp->lineCap());

   181     }

   182     case LineJoinAttrNum: {

   183         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   184 

   185         return jsString(imp->lineJoin());

   186     }

   187     case MiterLimitAttrNum: {

   188         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   189 

   190         return jsNumber(imp->miterLimit());

   191     }

   192     case ShadowOffsetXAttrNum: {

   193         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   194 

   195         return jsNumber(imp->shadowOffsetX());

   196     }

   197     case ShadowOffsetYAttrNum: {

   198         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   199 

   200         return jsNumber(imp->shadowOffsetY());

   201     }

   202     case ShadowBlurAttrNum: {

   203         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   204 

   205         return jsNumber(imp->shadowBlur());

   206     }

   207     case ShadowColorAttrNum: {

   208         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   209 

   210         return jsString(imp->shadowColor());

   211     }

   212     case StrokeStyleAttrNum: {

   213         return strokeStyle(exec);

   214     }

   215     case FillStyleAttrNum: {

   216         return fillStyle(exec);

   217     }

   218     }

   219     return 0;

   220 }

   221 

   222 void JSCanvasRenderingContext2D::put(ExecState* exec, const Identifier& propertyName, JSValue* value, int attr)

   223 {

   224     lookupPut<JSCanvasRenderingContext2D, KJS::DOMObject>(exec, propertyName, value, attr, &JSCanvasRenderingContext2DTable, this);

   225 }

   226 

   227 void JSCanvasRenderingContext2D::putValueProperty(ExecState* exec, int token, JSValue* value, int /*attr*/)

   228 {

   229     switch (token) {

   230     case GlobalAlphaAttrNum: {

   231         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   232 

   233         imp->setGlobalAlpha(value->toFloat(exec));

   234         break;

   235     }

   236     case GlobalCompositeOperationAttrNum: {

   237         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   238 

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

   240         break;

   241     }

   242     case LineWidthAttrNum: {

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

   244 

   245         imp->setLineWidth(value->toFloat(exec));

   246         break;

   247     }

   248     case LineCapAttrNum: {

   249         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   250 

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

   252         break;

   253     }

   254     case LineJoinAttrNum: {

   255         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   256 

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

   258         break;

   259     }

   260     case MiterLimitAttrNum: {

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

   262 

   263         imp->setMiterLimit(value->toFloat(exec));

   264         break;

   265     }

   266     case ShadowOffsetXAttrNum: {

   267         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   268 

   269         imp->setShadowOffsetX(value->toFloat(exec));

   270         break;

   271     }

   272     case ShadowOffsetYAttrNum: {

   273         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   274 

   275         imp->setShadowOffsetY(value->toFloat(exec));

   276         break;

   277     }

   278     case ShadowBlurAttrNum: {

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

   280 

   281         imp->setShadowBlur(value->toFloat(exec));

   282         break;

   283     }

   284     case ShadowColorAttrNum: {

   285         CanvasRenderingContext2D* imp = static_cast<CanvasRenderingContext2D*>(impl());

   286 

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

   288         break;

   289     }

   290     case StrokeStyleAttrNum: {

   291         setStrokeStyle(exec, value);

   292         break;

   293     }

   294     case FillStyleAttrNum: {

   295         setFillStyle(exec, value);

   296         break;

   297     }

   298     }

   299 }

   300 

   301 JSValue* JSCanvasRenderingContext2DPrototypeFunction::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)

   302 {

   303     if (!thisObj->inherits(&JSCanvasRenderingContext2D::info))

   304       return throwError(exec, TypeError);

   305 

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

   307 

   308     switch (id) {

   309     case JSCanvasRenderingContext2D::SaveFuncNum: {

   310 

   311         imp->save();

   312         return jsUndefined();

   313     }

   314     case JSCanvasRenderingContext2D::RestoreFuncNum: {

   315 

   316         imp->restore();

   317         return jsUndefined();

   318     }

   319     case JSCanvasRenderingContext2D::ScaleFuncNum: {

   320         float sx = args[0]->toFloat(exec);

   321         float sy = args[1]->toFloat(exec);

   322 

   323         imp->scale(sx, sy);

   324         return jsUndefined();

   325     }

   326     case JSCanvasRenderingContext2D::RotateFuncNum: {

   327         float angle = args[0]->toFloat(exec);

   328 

   329         imp->rotate(angle);

   330         return jsUndefined();

   331     }

   332     case JSCanvasRenderingContext2D::TranslateFuncNum: {

   333         float tx = args[0]->toFloat(exec);

   334         float ty = args[1]->toFloat(exec);

   335 

   336         imp->translate(tx, ty);

   337         return jsUndefined();

   338     }

   339     case JSCanvasRenderingContext2D::CreateLinearGradientFuncNum: {

   340         float x0 = args[0]->toFloat(exec);

   341         float y0 = args[1]->toFloat(exec);

   342         float x1 = args[2]->toFloat(exec);

   343         float y1 = args[3]->toFloat(exec);

   344 

   345 

   346         KJS::JSValue* result = toJS(exec, WTF::getPtr(imp->createLinearGradient(x0, y0, x1, y1)));

   347         return result;

   348     }

   349     case JSCanvasRenderingContext2D::CreateRadialGradientFuncNum: {

   350         float x0 = args[0]->toFloat(exec);

   351         float y0 = args[1]->toFloat(exec);

   352         float r0 = args[2]->toFloat(exec);

   353         float x1 = args[3]->toFloat(exec);

   354         float y1 = args[4]->toFloat(exec);

   355         float r1 = args[5]->toFloat(exec);

   356 

   357 

   358         KJS::JSValue* result = toJS(exec, WTF::getPtr(imp->createRadialGradient(x0, y0, r0, x1, y1, r1)));

   359         return result;

   360     }

   361     case JSCanvasRenderingContext2D::ClearRectFuncNum: {

   362         ExceptionCode ec = 0;

   363         float x = args[0]->toFloat(exec);

   364         float y = args[1]->toFloat(exec);

   365         float width = args[2]->toFloat(exec);

   366         float height = args[3]->toFloat(exec);

   367 

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

   369         setDOMException(exec, ec);

   370         return jsUndefined();

   371     }

   372     case JSCanvasRenderingContext2D::FillRectFuncNum: {

   373         ExceptionCode ec = 0;

   374         float x = args[0]->toFloat(exec);

   375         float y = args[1]->toFloat(exec);

   376         float width = args[2]->toFloat(exec);

   377         float height = args[3]->toFloat(exec);

   378 

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

   380         setDOMException(exec, ec);

   381         return jsUndefined();

   382     }

   383     case JSCanvasRenderingContext2D::BeginPathFuncNum: {

   384 

   385         imp->beginPath();

   386         return jsUndefined();

   387     }

   388     case JSCanvasRenderingContext2D::ClosePathFuncNum: {

   389 

   390         imp->closePath();

   391         return jsUndefined();

   392     }

   393     case JSCanvasRenderingContext2D::MoveToFuncNum: {

   394         float x = args[0]->toFloat(exec);

   395         float y = args[1]->toFloat(exec);

   396 

   397         imp->moveTo(x, y);

   398         return jsUndefined();

   399     }

   400     case JSCanvasRenderingContext2D::LineToFuncNum: {

   401         float x = args[0]->toFloat(exec);

   402         float y = args[1]->toFloat(exec);

   403 

   404         imp->lineTo(x, y);

   405         return jsUndefined();

   406     }

   407     case JSCanvasRenderingContext2D::QuadraticCurveToFuncNum: {

   408         float cpx = args[0]->toFloat(exec);

   409         float cpy = args[1]->toFloat(exec);

   410         float x = args[2]->toFloat(exec);

   411         float y = args[3]->toFloat(exec);

   412 

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

   414         return jsUndefined();

   415     }

   416     case JSCanvasRenderingContext2D::BezierCurveToFuncNum: {

   417         float cp1x = args[0]->toFloat(exec);

   418         float cp1y = args[1]->toFloat(exec);

   419         float cp2x = args[2]->toFloat(exec);

   420         float cp2y = args[3]->toFloat(exec);

   421         float x = args[4]->toFloat(exec);

   422         float y = args[5]->toFloat(exec);

   423 

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

   425         return jsUndefined();

   426     }

   427     case JSCanvasRenderingContext2D::ArcToFuncNum: {

   428         ExceptionCode ec = 0;

   429         float x1 = args[0]->toFloat(exec);

   430         float y1 = args[1]->toFloat(exec);

   431         float x2 = args[2]->toFloat(exec);

   432         float y2 = args[3]->toFloat(exec);

   433         float radius = args[4]->toFloat(exec);

   434 

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

   436         setDOMException(exec, ec);

   437         return jsUndefined();

   438     }

   439     case JSCanvasRenderingContext2D::RectFuncNum: {

   440         ExceptionCode ec = 0;

   441         float x = args[0]->toFloat(exec);

   442         float y = args[1]->toFloat(exec);

   443         float width = args[2]->toFloat(exec);

   444         float height = args[3]->toFloat(exec);

   445 

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

   447         setDOMException(exec, ec);

   448         return jsUndefined();

   449     }

   450     case JSCanvasRenderingContext2D::ArcFuncNum: {

   451         ExceptionCode ec = 0;

   452         float x = args[0]->toFloat(exec);

   453         float y = args[1]->toFloat(exec);

   454         float radius = args[2]->toFloat(exec);

   455         float startAngle = args[3]->toFloat(exec);

   456         float endAngle = args[4]->toFloat(exec);

   457         bool clockwise = args[5]->toBoolean(exec);

   458 

   459         imp->arc(x, y, radius, startAngle, endAngle, clockwise, ec);

   460         setDOMException(exec, ec);

   461         return jsUndefined();

   462     }

   463     case JSCanvasRenderingContext2D::FillFuncNum: {

   464 

   465         imp->fill();

   466         return jsUndefined();

   467     }

   468     case JSCanvasRenderingContext2D::StrokeFuncNum: {

   469 

   470         imp->stroke();

   471         return jsUndefined();

   472     }

   473     case JSCanvasRenderingContext2D::ClipFuncNum: {

   474 

   475         imp->clip();

   476         return jsUndefined();

   477     }

   478     case JSCanvasRenderingContext2D::SetAlphaFuncNum: {

   479         float alpha = args[0]->toFloat(exec);

   480 

   481         imp->setAlpha(alpha);

   482         return jsUndefined();

   483     }

   484     case JSCanvasRenderingContext2D::SetCompositeOperationFuncNum: {

   485         String compositeOperation = args[0]->toString(exec);

   486 

   487         imp->setCompositeOperation(compositeOperation);

   488         return jsUndefined();

   489     }

   490     case JSCanvasRenderingContext2D::SetLineWidthFuncNum: {

   491         float width = args[0]->toFloat(exec);

   492 

   493         imp->setLineWidth(width);

   494         return jsUndefined();

   495     }

   496     case JSCanvasRenderingContext2D::SetLineCapFuncNum: {

   497         String cap = args[0]->toString(exec);

   498 

   499         imp->setLineCap(cap);

   500         return jsUndefined();

   501     }

   502     case JSCanvasRenderingContext2D::SetLineJoinFuncNum: {

   503         String join = args[0]->toString(exec);

   504 

   505         imp->setLineJoin(join);

   506         return jsUndefined();

   507     }

   508     case JSCanvasRenderingContext2D::SetMiterLimitFuncNum: {

   509         float limit = args[0]->toFloat(exec);

   510 

   511         imp->setMiterLimit(limit);

   512         return jsUndefined();

   513     }

   514     case JSCanvasRenderingContext2D::ClearShadowFuncNum: {

   515 

   516         imp->clearShadow();

   517         return jsUndefined();

   518     }

   519     case JSCanvasRenderingContext2D::SetStrokeColorFuncNum: {

   520         return static_cast<JSCanvasRenderingContext2D*>(thisObj)->setStrokeColor(exec, args);

   521     }

   522     case JSCanvasRenderingContext2D::SetFillColorFuncNum: {

   523         return static_cast<JSCanvasRenderingContext2D*>(thisObj)->setFillColor(exec, args);

   524     }

   525     case JSCanvasRenderingContext2D::StrokeRectFuncNum: {

   526         return static_cast<JSCanvasRenderingContext2D*>(thisObj)->strokeRect(exec, args);

   527     }

   528     case JSCanvasRenderingContext2D::DrawImageFuncNum: {

   529         return static_cast<JSCanvasRenderingContext2D*>(thisObj)->drawImage(exec, args);

   530     }

   531     case JSCanvasRenderingContext2D::DrawImageFromRectFuncNum: {

   532         return static_cast<JSCanvasRenderingContext2D*>(thisObj)->drawImageFromRect(exec, args);

   533     }

   534     case JSCanvasRenderingContext2D::SetShadowFuncNum: {

   535         return static_cast<JSCanvasRenderingContext2D*>(thisObj)->setShadow(exec, args);

   536     }

   537     case JSCanvasRenderingContext2D::CreatePatternFuncNum: {

   538         return static_cast<JSCanvasRenderingContext2D*>(thisObj)->createPattern(exec, args);

   539     }

   540     }

   541     return 0;

   542 }

   543 KJS::JSValue* toJS(KJS::ExecState* exec, CanvasRenderingContext2D* obj)

   544 {

   545     return KJS::cacheDOMObject<CanvasRenderingContext2D, JSCanvasRenderingContext2D>(exec, obj);

   546 }

   547 CanvasRenderingContext2D* toCanvasRenderingContext2D(KJS::JSValue* val)

   548 {

   549     return val->isObject(&JSCanvasRenderingContext2D::info) ? static_cast<JSCanvasRenderingContext2D*>(val)->impl() : 0;

   550 }

   551 

   552 }