Merge branch 'wip/v4' of ssh://codereview.qt-project.org/qt/qtdeclarative into dev

Change-Id: I278524d0f43d2237201d9cf78c1c36a5ecc83d84

5 files changed, 1011 insertions, 869 deletions

diff --git a/src/quick/items/context2d/qquickcanvascontext_p.h b/src/quick/items/context2d/qquickcanvascontext_p.h
index d15f5d945d..2e3044008e 100644
--- a/src/quick/items/context2d/qquickcanvascontext_p.h
+++ b/src/quick/items/context2d/qquickcanvascontext_p.h
@@ -69,7 +69,7 @@ public:
     virtual void flush();
 
     virtual void setV8Engine(QV8Engine *engine) = 0;
-    virtual v8::Handle<v8::Object> v8value() const = 0;
+    virtual QV4::Value v4value() const = 0;
 
     virtual QSGDynamicTexture *texture() const = 0;
 
diff --git a/src/quick/items/context2d/qquickcanvasitem.cpp b/src/quick/items/context2d/qquickcanvasitem.cpp
index 8844eb91bb..55fb8b7fc5 100644
--- a/src/quick/items/context2d/qquickcanvasitem.cpp
+++ b/src/quick/items/context2d/qquickcanvasitem.cpp
@@ -50,6 +50,10 @@
 #include <qqmlinfo.h>
 #include <private/qqmlengine_p.h>
 #include <QtCore/QBuffer>
+#include <QtCore/qdatetime.h>
+
+#include <private/qv4value_p.h>
+#include <private/qv4functionobject_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -176,7 +180,7 @@ public:
     QString contextType;
     QHash<QUrl, QQmlRefPointer<QQuickCanvasPixmap> > pixmaps;
     QUrl baseUrl;
-    QMap<int, v8::Persistent<v8::Function> > animationCallbacks;
+    QMap<int, QV4::PersistentValue> animationCallbacks;
 };
 
 QQuickCanvasItemPrivate::QQuickCanvasItemPrivate()
@@ -359,13 +363,13 @@ void QQuickCanvasItem::setContextType(const QString &contextType)
     this property will contain the current drawing context, otherwise null.
 */
 
-QQmlV8Handle QQuickCanvasItem::context() const
+QQmlV4Handle QQuickCanvasItem::context() const
 {
     Q_D(const QQuickCanvasItem);
     if (d->context)
-        return QQmlV8Handle::fromHandle(d->context->v8value());
+        return QQmlV4Handle(d->context->v4value());
 
-    return QQmlV8Handle::fromHandle(v8::Null());
+    return QQmlV4Handle(QV4::Value::nullValue());
 }
 
 /*!
@@ -652,16 +656,15 @@ void QQuickCanvasItem::updatePolish()
         d->context->prepare(d->canvasSize.toSize(), d->tileSize, d->canvasWindow.toRect(), d->dirtyRect.toRect(), d->smooth, d->antialiasing);
 
     if (d->animationCallbacks.size() > 0 && isVisible()) {
-        QMap<int, v8::Persistent<v8::Function> > animationCallbacks = d->animationCallbacks;
+        QMap<int, QV4::PersistentValue> animationCallbacks = d->animationCallbacks;
         d->animationCallbacks.clear();
 
         foreach (int key, animationCallbacks.keys()) {
-            v8::HandleScope handle_scope;
-            v8::Handle<v8::Object> self = QQmlEnginePrivate::getV8Engine(qmlEngine(this))->newQObject(this).As<v8::Object>();
-            v8::Handle<v8::Value> args[] = { v8::Uint32::New(QDateTime::currentDateTimeUtc().toTime_t()) };
-            v8::Persistent<v8::Function> f = animationCallbacks.value(key);
-            f->Call(self, 1, args);
-            f.Dispose();
+            QV4::ExecutionEngine *v4 = QQmlEnginePrivate::getV4Engine(qmlEngine(this));
+            QV4::Value self = QV4::QObjectWrapper::wrap(v4, this);
+            QV4::Value args[] = { QV4::Value::fromUInt32(QDateTime::currentDateTimeUtc().toTime_t()) };
+            QV4::FunctionObject *f = animationCallbacks.value(key).value().asFunctionObject();
+            f->call(self, args, 1);
         }
     }
     else {
@@ -728,39 +731,39 @@ QSGNode *QQuickCanvasItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData
     Canvas only supports a 2d context.
 */
 
-void QQuickCanvasItem::getContext(QQmlV8Function *args)
+void QQuickCanvasItem::getContext(QQmlV4Function *args)
 {
     Q_D(QQuickCanvasItem);
 
-    if (args->Length() < 1 || !(*args)[0]->IsString()) {
+    if (args->length() < 1 || !(*args)[0].isString()) {
         qmlInfo(this) << "getContext should be called with a string naming the required context type";
-        args->returnValue(v8::Null());
+        args->setReturnValue(QV4::Value::nullValue());
         return;
     }
 
     if (!d->available) {
         qmlInfo(this) << "Unable to use getContext() at this time, please wait for available: true";
-        args->returnValue(v8::Null());
+        args->setReturnValue(QV4::Value::nullValue());
         return;
     }
 
-    QString contextId = QString::fromUtf16(*v8::String::Value((*args)[0]));
+    QString contextId = (*args)[0].toQString();
 
     if (d->context != 0) {
         if (d->context->contextNames().contains(contextId, Qt::CaseInsensitive)) {
-            args->returnValue(d->context->v8value());
+            args->setReturnValue(d->context->v4value());
             return;
         }
 
         qmlInfo(this) << "Canvas already initialized with a different context type";
-        args->returnValue(v8::Null());
+        args->setReturnValue(QV4::Value::nullValue());
         return;
     }
 
     if (createContext(contextId))
-        args->returnValue(d->context->v8value());
+        args->setReturnValue(d->context->v4value());
     else
-        args->returnValue(v8::Null());
+        args->setReturnValue(QV4::Value::nullValue());
 }
 
 /*!
@@ -770,11 +773,11 @@ void QQuickCanvasItem::getContext(QQmlV8Function *args)
     scene.
 */
 
-void QQuickCanvasItem::requestAnimationFrame(QQmlV8Function *args)
+void QQuickCanvasItem::requestAnimationFrame(QQmlV4Function *args)
 {
-    if (args->Length() < 1 || !(*args)[0]->IsFunction()) {
+    if (args->length() < 1 || !(*args)[0].asFunctionObject()) {
         qmlInfo(this) << "requestAnimationFrame should be called with an animation callback function";
-        args->returnValue(v8::Null());
+        args->setReturnValue(QV4::Value::nullValue());
         return;
     }
 
@@ -782,12 +785,12 @@ void QQuickCanvasItem::requestAnimationFrame(QQmlV8Function *args)
 
     static int id = 0;
 
-    d->animationCallbacks.insert(++id, v8::Persistent<v8::Function>::New(((*args)[0]).As<v8::Function>()));
+    d->animationCallbacks.insert(++id, QV4::PersistentValue((*args)[0]));
 
     if (isVisible())
         polish();
 
-    args->returnValue(v8::Int32::New(id));
+    args->setReturnValue(QV4::Value::fromInt32(id));
 }
 
 /*!
@@ -796,15 +799,15 @@ void QQuickCanvasItem::requestAnimationFrame(QQmlV8Function *args)
     This function will cancel the animation callback referenced by \a handle.
 */
 
-void QQuickCanvasItem::cancelRequestAnimationFrame(QQmlV8Function *args)
+void QQuickCanvasItem::cancelRequestAnimationFrame(QQmlV4Function *args)
 {
-    if (args->Length() < 1 || !(*args)[0]->IsInt32()) {
+    if (args->length() < 1 || !(*args)[0].isInteger()) {
         qmlInfo(this) << "cancelRequestAnimationFrame should be called with an animation callback id";
-        args->returnValue(v8::Null());
+        args->setReturnValue(QV4::Value::nullValue());
         return;
     }
 
-    d_func()->animationCallbacks.remove((*args)[0]->Int32Value());
+    d_func()->animationCallbacks.remove((*args)[0].integerValue());
 }
 
 
diff --git a/src/quick/items/context2d/qquickcanvasitem_p.h b/src/quick/items/context2d/qquickcanvasitem_p.h
index c53e4f952a..09922f1045 100644
--- a/src/quick/items/context2d/qquickcanvasitem_p.h
+++ b/src/quick/items/context2d/qquickcanvasitem_p.h
@@ -85,7 +85,7 @@ class QQuickCanvasItem : public QQuickItem
 
     Q_PROPERTY(bool available READ isAvailable NOTIFY availableChanged)
     Q_PROPERTY(QString contextType READ contextType WRITE setContextType NOTIFY contextTypeChanged)
-    Q_PROPERTY(QQmlV8Handle context READ context NOTIFY contextChanged)
+    Q_PROPERTY(QQmlV4Handle context READ context NOTIFY contextChanged)
     Q_PROPERTY(QSizeF canvasSize READ canvasSize WRITE setCanvasSize NOTIFY canvasSizeChanged)
     Q_PROPERTY(QSize tileSize READ tileSize WRITE setTileSize NOTIFY tileSizeChanged)
     Q_PROPERTY(QRectF canvasWindow READ canvasWindow WRITE setCanvasWindow NOTIFY canvasWindowChanged)
@@ -112,7 +112,7 @@ public:
     QString contextType() const;
     void setContextType(const QString &contextType);
 
-    QQmlV8Handle context() const;
+    QQmlV4Handle context() const;
 
     QSizeF canvasSize() const;
     void setCanvasSize(const QSizeF &);
@@ -133,10 +133,10 @@ public:
 
     QImage toImage(const QRectF& rect = QRectF()) const;
 
-    Q_INVOKABLE void getContext(QQmlV8Function *args);
+    Q_INVOKABLE void getContext(QQmlV4Function *args);
 
-    Q_INVOKABLE void requestAnimationFrame(QQmlV8Function *args);
-    Q_INVOKABLE void cancelRequestAnimationFrame(QQmlV8Function *args);
+    Q_INVOKABLE void requestAnimationFrame(QQmlV4Function *args);
+    Q_INVOKABLE void cancelRequestAnimationFrame(QQmlV4Function *args);
 
     Q_INVOKABLE void requestPaint();
     Q_INVOKABLE void markDirty(const QRectF& dirtyRect = QRectF());
diff --git a/src/quick/items/context2d/qquickcontext2d.cpp b/src/quick/items/context2d/qquickcontext2d.cpp
index 428ab08bb6..d2014ded8c 100644
--- a/src/quick/items/context2d/qquickcontext2d.cpp
+++ b/src/quick/items/context2d/qquickcontext2d.cpp
@@ -59,10 +59,16 @@
 #include <private/qv8engine_p.h>
 
 #include <qqmlengine.h>
-#include <private/qv8domerrors_p.h>
+#include <private/qv4domerrors_p.h>
+#include <private/qv4engine_p.h>
+#include <private/qv4object_p.h>
 #include <QtCore/qnumeric.h>
 #include <private/qquickwindow_p.h>
 
+#include <private/qv4value_p.h>
+#include <private/qv4functionobject_p.h>
+#include <private/qv4objectproto_p.h>
+
 #if defined(Q_OS_QNX) || defined(Q_OS_ANDROID)
 #include <ctype.h>
 #endif
@@ -114,17 +120,17 @@ static const double Q_PI   = 3.14159265358979323846;   // pi
 #define DEGREES(t) ((t) * 180.0 / Q_PI)
 
 #define CHECK_CONTEXT(r)     if (!r || !r->context || !r->context->bufferValid()) \
-                                V8THROW_ERROR("Not a Context2D object");
+                                V4THROW_ERROR("Not a Context2D object");
 
 #define CHECK_CONTEXT_SETTER(r)     if (!r || !r->context || !r->context->bufferValid()) \
-                                       V8THROW_ERROR_SETTER("Not a Context2D object");
+                                       V4THROW_ERROR("Not a Context2D object");
 #define qClamp(val, min, max) qMin(qMax(val, min), max)
 #define CHECK_RGBA(c) (c == '-' || c == '.' || (c >=0 && c <= 9))
-QColor qt_color_from_string(v8::Local<v8::Value> name)
+QColor qt_color_from_string(const QV4::Value &name)
 {
-    v8::String::AsciiValue str(name);
+    QByteArray str = name.toQString().toUtf8();
 
-    char *p = *str;
+    char *p = str.data();
     int len = str.length();
     //rgb/hsl color string has at least 7 characters
     if (!p || len > 255 || len <= 7)
@@ -462,46 +468,204 @@ public:
     QQuickContext2DEngineData(QV8Engine *engine);
     ~QQuickContext2DEngineData();
 
-    v8::Persistent<v8::Function> constructorContext;
-    v8::Persistent<v8::Function> constructorGradient;
-    v8::Persistent<v8::Function> constructorPattern;
-    v8::Persistent<v8::Function> constructorPixelArray;
-    v8::Persistent<v8::Function> constructorImageData;
+    QV4::PersistentValue contextPrototype;
+    QV4::PersistentValue gradientProto;
+    QV4::PersistentValue pixelArrayProto;
 };
 
 V8_DEFINE_EXTENSION(QQuickContext2DEngineData, engineData)
 
-class QV8Context2DResource : public QV8ObjectResource
+
+class QQuickJSContext2D : public QV4::Object
 {
-    V8_RESOURCE_TYPE(Context2DType)
+    Q_MANAGED
 public:
-    QV8Context2DResource(QV8Engine *e) : QV8ObjectResource(e), context(0) {}
+    QQuickJSContext2D(QV4::ExecutionEngine *engine)
+        : QV4::Object(engine)
+    {
+        vtbl = &static_vtbl;
+    }
     QQuickContext2D* context;
+
+    static QV4::Value method_get_globalAlpha(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_globalAlpha(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_globalCompositeOperation(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_globalCompositeOperation(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_fillStyle(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_fillStyle(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_fillRule(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_fillRule(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_strokeStyle(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_strokeStyle(QV4::SimpleCallContext *ctx);
+
+    static QV4::Value method_get_lineCap(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_lineCap(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_lineJoin(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_lineJoin(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_lineWidth(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_lineWidth(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_miterLimit(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_miterLimit(QV4::SimpleCallContext *ctx);
+
+    static QV4::Value method_get_shadowBlur(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_shadowBlur(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_shadowColor(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_shadowColor(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_shadowOffsetX(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_shadowOffsetX(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_shadowOffsetY(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_shadowOffsetY(QV4::SimpleCallContext *ctx);
+
+    // should these two be on the proto?
+    static QV4::Value method_get_path(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_path(QV4::SimpleCallContext *ctx);
+
+    static QV4::Value method_get_font(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_font(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_textAlign(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_textAlign(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_textBaseline(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_set_textBaseline(QV4::SimpleCallContext *ctx);
+
+protected:
+    static void destroy(Managed *that)
+    {
+        static_cast<QQuickJSContext2D *>(that)->~QQuickJSContext2D();
+    }
+};
+
+DEFINE_MANAGED_VTABLE(QQuickJSContext2D);
+
+
+struct QQuickJSContext2DPrototype : public QV4::Object
+{
+    Q_MANAGED
+public:
+    QQuickJSContext2DPrototype(QV4::ExecutionEngine *engine)
+        : QV4::Object(engine)
+    {
+        prototype = engine->objectPrototype;
+        defineDefaultProperty(engine, QStringLiteral("quadraticCurveTo"), method_quadraticCurveTo, 0);
+        defineDefaultProperty(engine, QStringLiteral("restore"), method_restore, 0);
+        defineDefaultProperty(engine, QStringLiteral("moveTo"), method_moveTo, 0);
+        defineDefaultProperty(engine, QStringLiteral("lineTo"), method_lineTo, 0);
+        defineDefaultProperty(engine, QStringLiteral("caretBlinkRate"), method_caretBlinkRate, 0);
+        defineDefaultProperty(engine, QStringLiteral("clip"), method_clip, 0);
+        defineDefaultProperty(engine, QStringLiteral("setTransform"), method_setTransform, 0);
+        defineDefaultProperty(engine, QStringLiteral("text"), method_text, 0);
+        defineDefaultProperty(engine, QStringLiteral("roundedRect"), method_roundedRect, 0);
+        defineDefaultProperty(engine, QStringLiteral("createPattern"), method_createPattern, 0);
+        defineDefaultProperty(engine, QStringLiteral("stroke"), method_stroke, 0);
+        defineDefaultProperty(engine, QStringLiteral("arc"), method_arc, 0);
+        defineDefaultProperty(engine, QStringLiteral("createImageData"), method_createImageData, 0);
+        defineDefaultProperty(engine, QStringLiteral("measureText"), method_measureText, 0);
+        defineDefaultProperty(engine, QStringLiteral("ellipse"), method_ellipse, 0);
+        defineDefaultProperty(engine, QStringLiteral("fill"), method_fill, 0);
+        defineDefaultProperty(engine, QStringLiteral("save"), method_save, 0);
+        defineDefaultProperty(engine, QStringLiteral("scale"), method_scale, 0);
+        defineDefaultProperty(engine, QStringLiteral("drawImage"), method_drawImage, 0);
+        defineDefaultProperty(engine, QStringLiteral("transform"), method_transform, 0);
+        defineDefaultProperty(engine, QStringLiteral("fillText"), method_fillText, 0);
+        defineDefaultProperty(engine, QStringLiteral("strokeText"), method_strokeText, 0);
+        defineDefaultProperty(engine, QStringLiteral("translate"), method_translate, 0);
+        defineDefaultProperty(engine, QStringLiteral("createRadialGradient"), method_createRadialGradient, 0);
+        defineDefaultProperty(engine, QStringLiteral("shear"), method_shear, 0);
+        defineDefaultProperty(engine, QStringLiteral("isPointInPath"), method_isPointInPath, 0);
+        defineDefaultProperty(engine, QStringLiteral("bezierCurveTo"), method_bezierCurveTo, 0);
+        defineDefaultProperty(engine, QStringLiteral("resetTransform"), method_resetTransform, 0);
+        defineDefaultProperty(engine, QStringLiteral("arcTo"), method_arcTo, 0);
+        defineDefaultProperty(engine, QStringLiteral("fillRect"), method_fillRect, 0);
+        defineDefaultProperty(engine, QStringLiteral("createConicalGradient"), method_createConicalGradient, 0);
+        defineDefaultProperty(engine, QStringLiteral("drawFocusRing"), method_drawFocusRing, 0);
+        defineDefaultProperty(engine, QStringLiteral("beginPath"), method_beginPath, 0);
+        defineDefaultProperty(engine, QStringLiteral("clearRect"), method_clearRect, 0);
+        defineDefaultProperty(engine, QStringLiteral("rect"), method_rect, 0);
+        defineDefaultProperty(engine, QStringLiteral("reset"), method_reset, 0);
+        defineDefaultProperty(engine, QStringLiteral("rotate"), method_rotate, 0);
+        defineDefaultProperty(engine, QStringLiteral("setCaretSelectionRect"), method_setCaretSelectionRect, 0);
+        defineDefaultProperty(engine, QStringLiteral("putImageData"), method_putImageData, 0);
+        defineDefaultProperty(engine, QStringLiteral("getImageData"), method_getImageData, 0);
+        defineDefaultProperty(engine, QStringLiteral("createLinearGradient"), method_createLinearGradient, 0);
+        defineDefaultProperty(engine, QStringLiteral("strokeRect"), method_strokeRect, 0);
+        defineDefaultProperty(engine, QStringLiteral("closePath"), method_closePath, 0);
+        defineAccessorProperty(engine, QStringLiteral("canvas"), QQuickJSContext2DPrototype::method_get_canvas, 0);
+    }
+
+    static QV4::Value method_get_canvas(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_restore(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_reset(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_save(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_rotate(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_scale(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_translate(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_setTransform(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_transform(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_resetTransform(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_shear(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_createLinearGradient(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_createRadialGradient(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_createConicalGradient(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_createPattern(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_clearRect(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_fillRect(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_strokeRect(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_arc(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_arcTo(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_beginPath(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_bezierCurveTo(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_clip(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_closePath(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_fill(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_lineTo(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_moveTo(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_quadraticCurveTo(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_rect(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_roundedRect(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_ellipse(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_text(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_stroke(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_isPointInPath(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_drawFocusRing(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_setCaretSelectionRect(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_caretBlinkRate(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_fillText(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_strokeText(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_measureText(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_drawImage(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_createImageData(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_getImageData(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_putImageData(QV4::SimpleCallContext *ctx);
+
 };
 
-class QV8Context2DStyleResource : public QV8ObjectResource
+DEFINE_MANAGED_VTABLE(QQuickJSContext2DPrototype);
+
+
+class QQuickContext2DStyle : public QV4::Object
 {
-    V8_RESOURCE_TYPE(Context2DStyleType)
+    Q_MANAGED
 public:
-    QV8Context2DStyleResource(QV8Engine *e)
-      : QV8ObjectResource(e)
+    QQuickContext2DStyle(QV4::ExecutionEngine *e)
+      : QV4::Object(e)
       , patternRepeatX(false)
       , patternRepeatY(false)
-    {}
+    {
+        vtbl = &static_vtbl;
+    }
     QBrush brush;
     bool patternRepeatX:1;
     bool patternRepeatY:1;
-};
-
-class QV8Context2DPixelArrayResource : public QV8ObjectResource
-{
-    V8_RESOURCE_TYPE(Context2DPixelArrayType)
-public:
-    QV8Context2DPixelArrayResource(QV8Engine *e) : QV8ObjectResource(e) {}
 
-    QImage image;
+    static QV4::Value gradient_proto_addColorStop(QV4::SimpleCallContext *ctx);
+protected:
+    static void destroy(Managed *that)
+    {
+        static_cast<QQuickContext2DStyle *>(that)->~QQuickContext2DStyle();
+    }
 };
 
+DEFINE_MANAGED_VTABLE(QQuickContext2DStyle);
+
 QImage qt_image_convolute_filter(const QImage& src, const QVector<qreal>& weights, int radius = 0)
 {
     // weights 3x3 => delta 1
@@ -588,53 +752,53 @@ void qt_image_boxblur(QImage& image, int radius, bool quality)
 
 static QPainter::CompositionMode qt_composite_mode_from_string(const QString &compositeOperator)
 {
-    if (compositeOperator == QLatin1String("source-over")) {
+    if (compositeOperator == QStringLiteral("source-over")) {
         return QPainter::CompositionMode_SourceOver;
-    } else if (compositeOperator == QLatin1String("source-out")) {
+    } else if (compositeOperator == QStringLiteral("source-out")) {
         return QPainter::CompositionMode_SourceOut;
-    } else if (compositeOperator == QLatin1String("source-in")) {
+    } else if (compositeOperator == QStringLiteral("source-in")) {
         return QPainter::CompositionMode_SourceIn;
-    } else if (compositeOperator == QLatin1String("source-atop")) {
+    } else if (compositeOperator == QStringLiteral("source-atop")) {
         return QPainter::CompositionMode_SourceAtop;
-    } else if (compositeOperator == QLatin1String("destination-atop")) {
+    } else if (compositeOperator == QStringLiteral("destination-atop")) {
         return QPainter::CompositionMode_DestinationAtop;
-    } else if (compositeOperator == QLatin1String("destination-in")) {
+    } else if (compositeOperator == QStringLiteral("destination-in")) {
         return QPainter::CompositionMode_DestinationIn;
-    } else if (compositeOperator == QLatin1String("destination-out")) {
+    } else if (compositeOperator == QStringLiteral("destination-out")) {
         return QPainter::CompositionMode_DestinationOut;
-    } else if (compositeOperator == QLatin1String("destination-over")) {
+    } else if (compositeOperator == QStringLiteral("destination-over")) {
         return QPainter::CompositionMode_DestinationOver;
-    } else if (compositeOperator == QLatin1String("lighter")) {
+    } else if (compositeOperator == QStringLiteral("lighter")) {
         return QPainter::CompositionMode_Lighten;
-    } else if (compositeOperator == QLatin1String("copy")) {
+    } else if (compositeOperator == QStringLiteral("copy")) {
         return QPainter::CompositionMode_Source;
-    } else if (compositeOperator == QLatin1String("xor")) {
+    } else if (compositeOperator == QStringLiteral("xor")) {
         return QPainter::CompositionMode_Xor;
-    } else if (compositeOperator == QLatin1String("qt-clear")) {
+    } else if (compositeOperator == QStringLiteral("qt-clear")) {
         return QPainter::CompositionMode_Clear;
-    } else if (compositeOperator == QLatin1String("qt-destination")) {
+    } else if (compositeOperator == QStringLiteral("qt-destination")) {
         return QPainter::CompositionMode_Destination;
-    } else if (compositeOperator == QLatin1String("qt-multiply")) {
+    } else if (compositeOperator == QStringLiteral("qt-multiply")) {
         return QPainter::CompositionMode_Multiply;
-    } else if (compositeOperator == QLatin1String("qt-screen")) {
+    } else if (compositeOperator == QStringLiteral("qt-screen")) {
         return QPainter::CompositionMode_Screen;
-    } else if (compositeOperator == QLatin1String("qt-overlay")) {
+    } else if (compositeOperator == QStringLiteral("qt-overlay")) {
         return QPainter::CompositionMode_Overlay;
-    } else if (compositeOperator == QLatin1String("qt-darken")) {
+    } else if (compositeOperator == QStringLiteral("qt-darken")) {
         return QPainter::CompositionMode_Darken;
-    } else if (compositeOperator == QLatin1String("qt-lighten")) {
+    } else if (compositeOperator == QStringLiteral("qt-lighten")) {
         return QPainter::CompositionMode_Lighten;
-    } else if (compositeOperator == QLatin1String("qt-color-dodge")) {
+    } else if (compositeOperator == QStringLiteral("qt-color-dodge")) {
         return QPainter::CompositionMode_ColorDodge;
-    } else if (compositeOperator == QLatin1String("qt-color-burn")) {
+    } else if (compositeOperator == QStringLiteral("qt-color-burn")) {
         return QPainter::CompositionMode_ColorBurn;
-    } else if (compositeOperator == QLatin1String("qt-hard-light")) {
+    } else if (compositeOperator == QStringLiteral("qt-hard-light")) {
         return QPainter::CompositionMode_HardLight;
-    } else if (compositeOperator == QLatin1String("qt-soft-light")) {
+    } else if (compositeOperator == QStringLiteral("qt-soft-light")) {
         return QPainter::CompositionMode_SoftLight;
-    } else if (compositeOperator == QLatin1String("qt-difference")) {
+    } else if (compositeOperator == QStringLiteral("qt-difference")) {
         return QPainter::CompositionMode_Difference;
-    } else if (compositeOperator == QLatin1String("qt-exclusion")) {
+    } else if (compositeOperator == QStringLiteral("qt-exclusion")) {
         return QPainter::CompositionMode_Exclusion;
     }
     return QPainter::CompositionMode_SourceOver;
@@ -644,77 +808,127 @@ static QString qt_composite_mode_to_string(QPainter::CompositionMode op)
 {
     switch (op) {
     case QPainter::CompositionMode_SourceOver:
-        return QLatin1String("source-over");
+        return QStringLiteral("source-over");
     case QPainter::CompositionMode_DestinationOver:
-        return QLatin1String("destination-over");
+        return QStringLiteral("destination-over");
     case QPainter::CompositionMode_Clear:
-        return QLatin1String("qt-clear");
+        return QStringLiteral("qt-clear");
     case QPainter::CompositionMode_Source:
-        return QLatin1String("copy");
+        return QStringLiteral("copy");
     case QPainter::CompositionMode_Destination:
-        return QLatin1String("qt-destination");
+        return QStringLiteral("qt-destination");
     case QPainter::CompositionMode_SourceIn:
-        return QLatin1String("source-in");
+        return QStringLiteral("source-in");
     case QPainter::CompositionMode_DestinationIn:
-        return QLatin1String("destination-in");
+        return QStringLiteral("destination-in");
     case QPainter::CompositionMode_SourceOut:
-        return QLatin1String("source-out");
+        return QStringLiteral("source-out");
     case QPainter::CompositionMode_DestinationOut:
-        return QLatin1String("destination-out");
+        return QStringLiteral("destination-out");
     case QPainter::CompositionMode_SourceAtop:
-        return QLatin1String("source-atop");
+        return QStringLiteral("source-atop");
     case QPainter::CompositionMode_DestinationAtop:
-        return QLatin1String("destination-atop");
+        return QStringLiteral("destination-atop");
     case QPainter::CompositionMode_Xor:
-        return QLatin1String("xor");
+        return QStringLiteral("xor");
     case QPainter::CompositionMode_Plus:
-        return QLatin1String("plus");
+        return QStringLiteral("plus");
     case QPainter::CompositionMode_Multiply:
-        return QLatin1String("qt-multiply");
+        return QStringLiteral("qt-multiply");
     case QPainter::CompositionMode_Screen:
-        return QLatin1String("qt-screen");
+        return QStringLiteral("qt-screen");
     case QPainter::CompositionMode_Overlay:
-        return QLatin1String("qt-overlay");
+        return QStringLiteral("qt-overlay");
     case QPainter::CompositionMode_Darken:
-        return QLatin1String("qt-darken");
+        return QStringLiteral("qt-darken");
     case QPainter::CompositionMode_Lighten:
-        return QLatin1String("lighter");
+        return QStringLiteral("lighter");
     case QPainter::CompositionMode_ColorDodge:
-        return QLatin1String("qt-color-dodge");
+        return QStringLiteral("qt-color-dodge");
     case QPainter::CompositionMode_ColorBurn:
-        return QLatin1String("qt-color-burn");
+        return QStringLiteral("qt-color-burn");
     case QPainter::CompositionMode_HardLight:
-        return QLatin1String("qt-hard-light");
+        return QStringLiteral("qt-hard-light");
     case QPainter::CompositionMode_SoftLight:
-        return QLatin1String("qt-soft-light");
+        return QStringLiteral("qt-soft-light");
     case QPainter::CompositionMode_Difference:
-        return QLatin1String("qt-difference");
+        return QStringLiteral("qt-difference");
     case QPainter::CompositionMode_Exclusion:
-        return QLatin1String("qt-exclusion");
+        return QStringLiteral("qt-exclusion");
     default:
         break;
     }
     return QString();
 }
 
+struct QQuickJSContext2DPixelData : public QV4::Object
+{
+    Q_MANAGED
+    QQuickJSContext2DPixelData(QV4::ExecutionEngine *engine)
+        : QV4::Object(engine)
+    {
+        vtbl = &static_vtbl;
+    }
+
+    static void destroy(QV4::Managed *that) {
+        static_cast<QQuickJSContext2DPixelData *>(that)->~QQuickJSContext2DPixelData();
+    }
+    static QV4::Value getIndexed(QV4::Managed *m, uint index, bool *hasProperty);
+    static void putIndexed(QV4::Managed *m, uint index, const QV4::Value &value);
+
+    static QV4::Value proto_get_length(QV4::SimpleCallContext *ctx);
+
+    QImage image;
+};
+
+DEFINE_MANAGED_VTABLE(QQuickJSContext2DPixelData);
+
+struct QQuickJSContext2DImageData : public QV4::Object
+{
+    Q_MANAGED
+    QQuickJSContext2DImageData(QV4::ExecutionEngine *engine)
+        : QV4::Object(engine)
+    {
+        vtbl = &static_vtbl;
+
+        defineAccessorProperty(engine, QStringLiteral("width"), method_get_width, 0);
+        defineAccessorProperty(engine, QStringLiteral("height"), method_get_height, 0);
+        defineAccessorProperty(engine, QStringLiteral("data"), method_get_data, 0);
+    }
+
+    static QV4::Value method_get_width(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_height(QV4::SimpleCallContext *ctx);
+    static QV4::Value method_get_data(QV4::SimpleCallContext *ctx);
+
+    static void markObjects(Managed *that) {
+        static_cast<QQuickJSContext2DImageData *>(that)->pixelData.mark();
+    }
+
+
 
-static v8::Local<v8::Object> qt_create_image_data(qreal w, qreal h, QV8Engine* engine, const QImage& image)
+    QV4::Value pixelData;
+};
+
+DEFINE_MANAGED_VTABLE(QQuickJSContext2DImageData);
+
+static QV4::Value qt_create_image_data(qreal w, qreal h, QV8Engine* engine, const QImage& image)
 {
     QQuickContext2DEngineData *ed = engineData(engine);
-    v8::Local<v8::Object> imageData = ed->constructorImageData->NewInstance();
-    QV8Context2DPixelArrayResource *r = new QV8Context2DPixelArrayResource(engine);
+    QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
+    QQuickJSContext2DPixelData *pixelData = new (v4->memoryManager) QQuickJSContext2DPixelData(v4);
+    pixelData->prototype = ed->pixelArrayProto.value().asObject();
+
     if (image.isNull()) {
-        r->image = QImage(w, h, QImage::Format_ARGB32);
-        r->image.fill(0x00000000);
+        pixelData->image = QImage(w, h, QImage::Format_ARGB32);
+        pixelData->image.fill(0x00000000);
     } else {
         Q_ASSERT(image.width() == int(w) && image.height() == int(h));
-        r->image = image.format() == QImage::Format_ARGB32 ? image : image.convertToFormat(QImage::Format_ARGB32);
+        pixelData->image = image.format() == QImage::Format_ARGB32 ? image : image.convertToFormat(QImage::Format_ARGB32);
     }
-    v8::Local<v8::Object> pixelData = ed->constructorPixelArray->NewInstance();
-    pixelData->SetExternalResource(r);
 
-    imageData->SetInternalField(0, pixelData);
-    return imageData;
+    QQuickJSContext2DImageData *imageData = new (v4->memoryManager) QQuickJSContext2DImageData(v4);
+    imageData->pixelData = QV4::Value::fromObject(pixelData);
+    return QV4::Value::fromObject(imageData);
 }
 
 //static script functions
@@ -725,15 +939,12 @@ static v8::Local<v8::Object> qt_create_image_data(qreal w, qreal h, QV8Engine* e
 
      This property is read only.
 */
-static v8::Handle<v8::Value> ctx2d_canvas(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2DPrototype::method_get_canvas(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-
-    return engine->newQObject(r->context->canvas());
+    return QV4::QObjectWrapper::wrap(ctx->engine, r->context->canvas());
 }
 
 /*!
@@ -742,27 +953,27 @@ static v8::Handle<v8::Value> ctx2d_canvas(v8::Local<v8::String>, const v8::Acces
 
     \sa save()
 */
-static v8::Handle<v8::Value> ctx2d_restore(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_restore(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->popState();
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
     \qmlmethod object QtQuick2::Context2D::reset()
     Resets the context state and properties to the default values.
 */
-static v8::Handle<v8::Value> ctx2d_reset(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_reset(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->reset();
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -795,14 +1006,14 @@ static v8::Handle<v8::Value> ctx2d_reset(const v8::Arguments &args)
     The current path is NOT part of the drawing state. The path can be reset by
     invoking the beginPath() method.
 */
-static v8::Handle<v8::Value> ctx2d_save(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_save(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->pushState();
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 // transformations
@@ -823,14 +1034,14 @@ static v8::Handle<v8::Value> ctx2d_save(const v8::Arguments &args)
     where the \a angle of rotation is in radians.
 
 */
-static v8::Handle<v8::Value> ctx2d_rotate(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_rotate(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    if (args.Length() == 1)
-        r->context->rotate(args[0]->NumberValue());
-    return args.This();
+    if (ctx->argumentCount == 1)
+        r->context->rotate(ctx->arguments[0].toNumber());
+    return ctx->thisObject;
 }
 
 /*!
@@ -850,15 +1061,15 @@ static v8::Handle<v8::Value> ctx2d_rotate(const v8::Arguments &args)
 
     \image qml-item-canvas-scale.png
 */
-static v8::Handle<v8::Value> ctx2d_scale(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_scale(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    if (args.Length() == 2)
-        r->context->scale(args[0]->NumberValue(), args[1]->NumberValue());
-    return args.This();
+    if (ctx->argumentCount == 2)
+        r->context->scale(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber());
+    return ctx->thisObject;
 }
 
 /*!
@@ -894,21 +1105,21 @@ static v8::Handle<v8::Value> ctx2d_scale(const v8::Arguments &args)
 
     \sa transform()
 */
-static v8::Handle<v8::Value> ctx2d_setTransform(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_setTransform(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    if (args.Length() == 6)
-        r->context->setTransform( args[0]->NumberValue()
-                                                        , args[1]->NumberValue()
-                                                        , args[2]->NumberValue()
-                                                        , args[3]->NumberValue()
-                                                        , args[4]->NumberValue()
-                                                        , args[5]->NumberValue());
+    if (ctx->argumentCount == 6)
+        r->context->setTransform( ctx->arguments[0].toNumber()
+                                                        , ctx->arguments[1].toNumber()
+                                                        , ctx->arguments[2].toNumber()
+                                                        , ctx->arguments[3].toNumber()
+                                                        , ctx->arguments[4].toNumber()
+                                                        , ctx->arguments[5].toNumber());
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -922,21 +1133,21 @@ static v8::Handle<v8::Value> ctx2d_setTransform(const v8::Arguments &args)
 
     \sa setTransform()
 */
-static v8::Handle<v8::Value> ctx2d_transform(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_transform(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    if (args.Length() == 6)
-        r->context->transform( args[0]->NumberValue()
-                                                  , args[1]->NumberValue()
-                                                  , args[2]->NumberValue()
-                                                  , args[3]->NumberValue()
-                                                  , args[4]->NumberValue()
-                                                  , args[5]->NumberValue());
+    if (ctx->argumentCount == 6)
+        r->context->transform( ctx->arguments[0].toNumber()
+                                                  , ctx->arguments[1].toNumber()
+                                                  , ctx->arguments[2].toNumber()
+                                                  , ctx->arguments[3].toNumber()
+                                                  , ctx->arguments[4].toNumber()
+                                                  , ctx->arguments[5].toNumber());
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -948,15 +1159,15 @@ static v8::Handle<v8::Value> ctx2d_transform(const v8::Arguments &args)
     Translating the origin enables you to draw patterns of different objects on the canvas
     without having to measure the coordinates manually for each shape.
 */
-static v8::Handle<v8::Value> ctx2d_translate(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_translate(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    if (args.Length() == 2)
-            r->context->translate(args[0]->NumberValue(), args[1]->NumberValue());
-    return args.This();
+    if (ctx->argumentCount == 2)
+            r->context->translate(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber());
+    return ctx->thisObject;
 }
 
 
@@ -968,14 +1179,14 @@ static v8::Handle<v8::Value> ctx2d_translate(const v8::Arguments &args)
 
     \sa transform(), setTransform(), reset()
 */
-static v8::Handle<v8::Value> ctx2d_resetTransform(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_resetTransform(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->setTransform(1, 0, 0, 1, 0, 0);
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 
@@ -985,15 +1196,15 @@ static v8::Handle<v8::Value> ctx2d_resetTransform(const v8::Arguments &args)
     Shears the transformation matrix by \a sh in the horizontal direction and
     \a sv in the vertical direction.
 */
-static v8::Handle<v8::Value> ctx2d_shear(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_shear(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    if (args.Length() == 2)
-            r->context->shear(args[0]->NumberValue(), args[1]->NumberValue());
+    if (ctx->argumentCount == 2)
+            r->context->shear(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber());
 
-    return args.This();
+    return ctx->thisObject;
 }
 // compositing
 
@@ -1004,28 +1215,29 @@ static v8::Handle<v8::Value> ctx2d_shear(const v8::Arguments &args)
      The value must be in the range from \c 0.0 (fully transparent) to \c 1.0 (fully opaque).
      The default value is \c 1.0.
 */
-static v8::Handle<v8::Value> ctx2d_globalAlpha(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_globalAlpha(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    return v8::Number::New(r->context->state.globalAlpha);
+    return QV4::Value::fromDouble(r->context->state.globalAlpha);
 }
 
-static void ctx2d_globalAlpha_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_globalAlpha(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    qreal globalAlpha = value->NumberValue();
+    double globalAlpha = ctx->argument(0).toNumber();
 
     if (!qIsFinite(globalAlpha))
-        return;
+        return QV4::Value::undefinedValue();
 
     if (globalAlpha >= 0.0 && globalAlpha <= 1.0 && r->context->state.globalAlpha != globalAlpha) {
         r->context->state.globalAlpha = globalAlpha;
         r->context->buffer()->setGlobalAlpha(r->context->state.globalAlpha);
     }
+    return QV4::Value::undefinedValue();
 }
 
 /*!
@@ -1054,34 +1266,29 @@ static void ctx2d_globalAlpha_set(v8::Local<v8::String>, v8::Local<v8::Value> va
      extension composition modes are provided as "vendorName-operationName" syntax, for example: QPainter::CompositionMode_Exclusion is provided as
      "qt-exclusion".
 */
-static v8::Handle<v8::Value> ctx2d_globalCompositeOperation(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_globalCompositeOperation(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-
-    return engine->toString(qt_composite_mode_to_string(r->context->state.globalCompositeOperation));
+    return QV4::Value::fromString(ctx->engine->newString(qt_composite_mode_to_string(r->context->state.globalCompositeOperation)));
 }
 
-static void ctx2d_globalCompositeOperation_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_globalCompositeOperation(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-
-
-    QString mode = engine->toString(value);
+    QString mode = ctx->argument(0).toQString();
     QPainter::CompositionMode cm = qt_composite_mode_from_string(mode);
     if (cm == QPainter::CompositionMode_SourceOver && mode != QStringLiteral("source-over"))
-        return;
+        return QV4::Value::undefinedValue();
 
     if (cm != r->context->state.globalCompositeOperation) {
         r->context->state.globalCompositeOperation = cm;
         r->context->buffer()->setGlobalCompositeOperation(cm);
     }
+    return QV4::Value::undefinedValue();
 }
 
 // colors and styles
@@ -1107,42 +1314,42 @@ static void ctx2d_globalCompositeOperation_set(v8::Local<v8::String>, v8::Local<
      \sa createPattern()
      \sa strokeStyle
  */
-static v8::Handle<v8::Value> ctx2d_fillStyle(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_fillStyle(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-
     QColor color = r->context->state.fillStyle.color();
     if (color.isValid()) {
         if (color.alpha() == 255)
-            return engine->toString(color.name());
+            return QV4::Value::fromString(ctx->engine->newString(color.name()));
         QString alphaString = QString::number(color.alphaF(), 'f');
         while (alphaString.endsWith(QLatin1Char('0')))
             alphaString.chop(1);
         if (alphaString.endsWith(QLatin1Char('.')))
             alphaString += QLatin1Char('0');
-        return engine->toString(QString::fromLatin1("rgba(%1, %2, %3, %4)").arg(color.red()).arg(color.green()).arg(color.blue()).arg(alphaString));
+        QString str = QString::fromLatin1("rgba(%1, %2, %3, %4)").arg(color.red()).arg(color.green()).arg(color.blue()).arg(alphaString);
+        return QV4::Value::fromString(ctx->engine->newString(str));
     }
-    return r->context->m_fillStyle;
+    return r->context->m_fillStyle.value();
 }
 
-static void ctx2d_fillStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_fillStyle(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
+    QV4::Value value = ctx->argument(0);
+    QV8Engine *engine = ctx->engine->v8Engine;
 
-   if (value->IsObject()) {
+   if (value.asObject()) {
        QColor color = engine->toVariant(value, qMetaTypeId<QColor>()).value<QColor>();
        if (color.isValid()) {
            r->context->state.fillStyle = color;
            r->context->buffer()->setFillStyle(color);
            r->context->m_fillStyle = value;
        } else {
-           QV8Context2DStyleResource *style = v8_resource_cast<QV8Context2DStyleResource>(value->ToObject());
+           QQuickContext2DStyle *style = value.as<QQuickContext2DStyle>();
            if (style && style->brush != r->context->state.fillStyle) {
                r->context->state.fillStyle = style->brush;
                r->context->buffer()->setFillStyle(style->brush, style->patternRepeatX, style->patternRepeatY);
@@ -1151,7 +1358,7 @@ static void ctx2d_fillStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> valu
                r->context->state.fillPatternRepeatY = style->patternRepeatY;
            }
        }
-   } else if (value->IsString()) {
+   } else if (value.isString()) {
        QColor color = qt_color_from_string(value);
        if (color.isValid() && r->context->state.fillStyle != QBrush(color)) {
             r->context->state.fillStyle = QBrush(color);
@@ -1159,6 +1366,7 @@ static void ctx2d_fillStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> valu
             r->context->m_fillStyle = value;
        }
    }
+   return QV4::Value::undefinedValue();
 }
 /*!
     \qmlproperty enumeration QtQuick2::Context2D::fillRule
@@ -1172,32 +1380,33 @@ static void ctx2d_fillStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> valu
 
      \sa fillStyle
  */
-static v8::Handle<v8::Value> ctx2d_fillRule(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_fillRule(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
 
+    QV8Engine *engine = ctx->engine->v8Engine;
     return engine->fromVariant(r->context->state.fillRule);
 }
 
-static void ctx2d_fillRule_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_fillRule(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
+    QV4::Value value = ctx->argument(0);
 
-    if ((value->IsString() && engine->toString(value) == QStringLiteral("WindingFill"))
-      ||(value->IsNumber() && value->NumberValue() == Qt::WindingFill)) {
+    if ((value.isString() && value.toQString() == QStringLiteral("WindingFill"))
+        || (value.isInt32() && value.integerValue() == Qt::WindingFill)) {
         r->context->state.fillRule = Qt::WindingFill;
-    } else if ((value->IsString() && engine->toString(value) == QStringLiteral("OddEvenFill"))
-               ||(value->IsNumber() && value->NumberValue() == Qt::OddEvenFill)) {
+    } else if ((value.isString() && value.toQString() == QStringLiteral("OddEvenFill"))
+               || (value.isInt32() && value.integerValue() == Qt::OddEvenFill)) {
         r->context->state.fillRule = Qt::OddEvenFill;
     } else {
         //error
     }
     r->context->m_path.setFillRule(r->context->state.fillRule);
+    return QV4::Value::undefinedValue();
 }
 /*!
     \qmlproperty variant QtQuick2::Context2D::strokeStyle
@@ -1212,42 +1421,42 @@ static void ctx2d_fillRule_set(v8::Local<v8::String>, v8::Local<v8::Value> value
      \sa createPattern()
      \sa fillStyle
  */
-v8::Handle<v8::Value> ctx2d_strokeStyle(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_strokeStyle(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-
     QColor color = r->context->state.strokeStyle.color();
     if (color.isValid()) {
         if (color.alpha() == 255)
-            return engine->toString(color.name());
+            return QV4::Value::fromString(ctx->engine->newString(color.name()));
         QString alphaString = QString::number(color.alphaF(), 'f');
         while (alphaString.endsWith(QLatin1Char('0')))
             alphaString.chop(1);
         if (alphaString.endsWith(QLatin1Char('.')))
             alphaString += QLatin1Char('0');
-        return engine->toString(QString::fromLatin1("rgba(%1, %2, %3, %4)").arg(color.red()).arg(color.green()).arg(color.blue()).arg(alphaString));
+        QString str = QString::fromLatin1("rgba(%1, %2, %3, %4)").arg(color.red()).arg(color.green()).arg(color.blue()).arg(alphaString);
+        return QV4::Value::fromString(ctx->engine->newString(str));
     }
-    return r->context->m_strokeStyle;
+    return r->context->m_strokeStyle.value();
 }
 
-static void ctx2d_strokeStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_strokeStyle(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
+    QV8Engine *engine = ctx->engine->v8Engine;
+    QV4::Value value = ctx->argument(0);
 
-    if (value->IsObject()) {
+    if (value.asObject()) {
         QColor color = engine->toVariant(value, qMetaTypeId<QColor>()).value<QColor>();
         if (color.isValid()) {
             r->context->state.fillStyle = color;
             r->context->buffer()->setStrokeStyle(color);
             r->context->m_strokeStyle = value;
         } else {
-            QV8Context2DStyleResource *style = v8_resource_cast<QV8Context2DStyleResource>(value->ToObject());
+            QQuickContext2DStyle *style = value.as<QQuickContext2DStyle>();
             if (style && style->brush != r->context->state.strokeStyle) {
                 r->context->state.strokeStyle = style->brush;
                 r->context->buffer()->setStrokeStyle(style->brush, style->patternRepeatX, style->patternRepeatY);
@@ -1257,7 +1466,7 @@ static void ctx2d_strokeStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> va
 
             }
         }
-    } else if (value->IsString()) {
+    } else if (value.isString()) {
         QColor color = qt_color_from_string(value);
         if (color.isValid() && r->context->state.strokeStyle != QBrush(color)) {
              r->context->state.strokeStyle = QBrush(color);
@@ -1265,6 +1474,7 @@ static void ctx2d_strokeStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> va
              r->context->m_strokeStyle = value;
         }
     }
+    return QV4::Value::undefinedValue();
 }
 
 /*!
@@ -1284,37 +1494,36 @@ static void ctx2d_strokeStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> va
     \sa strokeStyle
   */
 
-static v8::Handle<v8::Value> ctx2d_createLinearGradient(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_createLinearGradient(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    QV8Engine *engine = V8ENGINE();
+    QV8Engine *engine = ctx->engine->v8Engine;
+    QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
 
-    if (args.Length() == 4) {
-        QQuickContext2DEngineData *ed = engineData(engine);
-        v8::Local<v8::Object> gradient = ed->constructorGradient->NewInstance();
-        QV8Context2DStyleResource *r = new QV8Context2DStyleResource(engine);
-        qreal x0 = args[0]->NumberValue();
-        qreal y0 = args[1]->NumberValue();
-        qreal x1 = args[2]->NumberValue();
-        qreal y1 = args[3]->NumberValue();
+    if (ctx->argumentCount == 4) {
+        qreal x0 = ctx->arguments[0].toNumber();
+        qreal y0 = ctx->arguments[1].toNumber();
+        qreal x1 = ctx->arguments[2].toNumber();
+        qreal y1 = ctx->arguments[3].toNumber();
 
         if (!qIsFinite(x0)
          || !qIsFinite(y0)
          || !qIsFinite(x1)
          || !qIsFinite(y1)) {
-            delete r;
-            V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createLinearGradient(): Incorrect arguments")
+            V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createLinearGradient(): Incorrect arguments")
         }
+        QQuickContext2DEngineData *ed = engineData(engine);
 
-        r->brush = QLinearGradient(x0, y0, x1, y1);
-        gradient->SetExternalResource(r);
-        return gradient;
+        QQuickContext2DStyle *gradient = new (v4->memoryManager) QQuickContext2DStyle(v4);
+        gradient->prototype = ed->gradientProto.value().asObject();
+        gradient->brush = QLinearGradient(x0, y0, x1, y1);
+        return QV4::Value::fromObject(gradient);
     }
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -1330,25 +1539,22 @@ static v8::Handle<v8::Value> ctx2d_createLinearGradient(const v8::Arguments &arg
     \sa strokeStyle
   */
 
-static v8::Handle<v8::Value> ctx2d_createRadialGradient(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_createRadialGradient(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    QV8Engine *engine = V8ENGINE();
-
-    if (args.Length() == 6) {
-        QQuickContext2DEngineData *ed = engineData(engine);
-        v8::Local<v8::Object> gradient = ed->constructorGradient->NewInstance();
-        QV8Context2DStyleResource *r = new QV8Context2DStyleResource(engine);
+    QV8Engine *engine = ctx->engine->v8Engine;
+    QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
 
-        qreal x0 = args[0]->NumberValue();
-        qreal y0 = args[1]->NumberValue();
-        qreal r0 = args[2]->NumberValue();
-        qreal x1 = args[3]->NumberValue();
-        qreal y1 = args[4]->NumberValue();
-        qreal r1 = args[5]->NumberValue();
+    if (ctx->argumentCount == 6) {
+        qreal x0 = ctx->arguments[0].toNumber();
+        qreal y0 = ctx->arguments[1].toNumber();
+        qreal r0 = ctx->arguments[2].toNumber();
+        qreal x1 = ctx->arguments[3].toNumber();
+        qreal y1 = ctx->arguments[4].toNumber();
+        qreal r1 = ctx->arguments[5].toNumber();
 
         if (!qIsFinite(x0)
          || !qIsFinite(y0)
@@ -1356,20 +1562,21 @@ static v8::Handle<v8::Value> ctx2d_createRadialGradient(const v8::Arguments &arg
          || !qIsFinite(r0)
          || !qIsFinite(r1)
          || !qIsFinite(y1)) {
-            delete r;
-            V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createRadialGradient(): Incorrect arguments")
+            V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createRadialGradient(): Incorrect arguments")
         }
 
         if (r0 < 0 || r1 < 0)
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createRadialGradient(): Incorrect arguments")
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createRadialGradient(): Incorrect arguments")
 
+        QQuickContext2DEngineData *ed = engineData(engine);
 
-        r->brush = QRadialGradient(QPointF(x1, y1), r0+r1, QPointF(x0, y0));
-        gradient->SetExternalResource(r);
-        return gradient;
+        QQuickContext2DStyle *gradient = new (v4->memoryManager) QQuickContext2DStyle(v4);
+        gradient->prototype = ed->gradientProto.value().asObject();
+        gradient->brush = QRadialGradient(QPointF(x1, y1), r0+r1, QPointF(x0, y0));
+        return QV4::Value::fromObject(gradient);
     }
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -1385,38 +1592,36 @@ static v8::Handle<v8::Value> ctx2d_createRadialGradient(const v8::Arguments &arg
     \sa strokeStyle
   */
 
-static v8::Handle<v8::Value> ctx2d_createConicalGradient(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_createConicalGradient(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    QV8Engine *engine = V8ENGINE();
-
-    if (args.Length() == 6) {
-        QQuickContext2DEngineData *ed = engineData(engine);
-        v8::Local<v8::Object> gradient = ed->constructorGradient->NewInstance();
-        QV8Context2DStyleResource *r = new QV8Context2DStyleResource(engine);
+    QV8Engine *engine = ctx->engine->v8Engine;
+    QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
 
-        qreal x = args[0]->NumberValue();
-        qreal y = args[1]->NumberValue();
-        qreal angle = DEGREES(args[2]->NumberValue());
+    if (ctx->argumentCount == 6) {
+        qreal x = ctx->arguments[0].toNumber();
+        qreal y = ctx->arguments[1].toNumber();
+        qreal angle = DEGREES(ctx->arguments[2].toNumber());
         if (!qIsFinite(x) || !qIsFinite(y)) {
-            delete r;
-            V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createConicalGradient(): Incorrect arguments");
+            V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createConicalGradient(): Incorrect arguments");
         }
 
         if (!qIsFinite(angle)) {
-            delete r;
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createConicalGradient(): Incorrect arguments");
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createConicalGradient(): Incorrect arguments");
         }
 
-        r->brush = QConicalGradient(x, y, angle);
-        gradient->SetExternalResource(r);
-        return gradient;
+        QQuickContext2DEngineData *ed = engineData(engine);
+
+        QQuickContext2DStyle *gradient = new (v4->memoryManager) QQuickContext2DStyle(v4);
+        gradient->prototype = ed->gradientProto.value().asObject();
+        gradient->brush = QConicalGradient(x, y, angle);
+        return QV4::Value::fromObject(gradient);
     }
 
-    return args.This();
+    return ctx->thisObject;
 }
 /*!
   \qmlmethod variant QtQuick2::Context2D::createPattern(color color, enumeration patternMode)
@@ -1461,52 +1666,52 @@ static v8::Handle<v8::Value> ctx2d_createConicalGradient(const v8::Arguments &ar
   \sa strokeStyle
   \sa fillStyle
   */
-static v8::Handle<v8::Value> ctx2d_createPattern(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_createPattern(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    QV8Engine *engine = V8ENGINE();
+    QV8Engine *engine = ctx->engine->v8Engine;
+    QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
 
-    if (args.Length() == 2) {
-        QQuickContext2DEngineData *ed = engineData(engine);
-        QV8Context2DStyleResource *styleResouce = new QV8Context2DStyleResource(engine);
+    if (ctx->argumentCount == 2) {
+        QQuickContext2DStyle *pattern = new (v4->memoryManager) QQuickContext2DStyle(v4);
 
-        QColor color = engine->toVariant(args[0], qMetaTypeId<QColor>()).value<QColor>();
+        QColor color = engine->toVariant(ctx->arguments[0], qMetaTypeId<QColor>()).value<QColor>();
         if (color.isValid()) {
-            int patternMode = args[1]->IntegerValue();
+            int patternMode = ctx->arguments[1].toInt32();
             Qt::BrushStyle style = Qt::SolidPattern;
             if (patternMode >= 0 && patternMode < Qt::LinearGradientPattern) {
                 style = static_cast<Qt::BrushStyle>(patternMode);
             }
-            styleResouce->brush = QBrush(color, style);
+            pattern->brush = QBrush(color, style);
         } else {
             QImage patternTexture;
 
-            if (args[0]->IsObject()) {
-                QV8Context2DPixelArrayResource *pixelData = v8_resource_cast<QV8Context2DPixelArrayResource>(args[0]->ToObject()->Get(v8::String::New("data"))->ToObject());
+            if (QV4::Object *o = ctx->arguments[0].asObject()) {
+                QQuickJSContext2DPixelData *pixelData = o->get(ctx->engine->newString(QStringLiteral("data"))).as<QQuickJSContext2DPixelData>();
                 if (pixelData) {
                     patternTexture = pixelData->image;
                 }
             } else {
-                patternTexture = r->context->createPixmap(QUrl(engine->toString(args[0]->ToString())))->image();
+                patternTexture = r->context->createPixmap(QUrl(ctx->arguments[0].toQString()))->image();
             }
 
             if (!patternTexture.isNull()) {
-                styleResouce->brush.setTextureImage(patternTexture);
+                pattern->brush.setTextureImage(patternTexture);
 
-                QString repetition = engine->toString(args[1]);
+                QString repetition = ctx->arguments[1].toQString();
                 if (repetition == QStringLiteral("repeat") || repetition.isEmpty()) {
-                    styleResouce->patternRepeatX = true;
-                    styleResouce->patternRepeatY = true;
+                    pattern->patternRepeatX = true;
+                    pattern->patternRepeatY = true;
                 } else if (repetition == QStringLiteral("repeat-x")) {
-                    styleResouce->patternRepeatX = true;
+                    pattern->patternRepeatX = true;
                 } else if (repetition == QStringLiteral("repeat-y")) {
-                    styleResouce->patternRepeatY = true;
+                    pattern->patternRepeatY = true;
                 } else if (repetition == QStringLiteral("no-repeat")) {
-                    styleResouce->patternRepeatY = false;
-                    styleResouce->patternRepeatY = false;
+                    pattern->patternRepeatY = false;
+                    pattern->patternRepeatY = false;
                 } else {
                     //TODO: exception: SYNTAX_ERR
                 }
@@ -1514,12 +1719,10 @@ static v8::Handle<v8::Value> ctx2d_createPattern(const v8::Arguments &args)
             }
         }
 
-        v8::Local<v8::Object> pattern = ed->constructorPattern->NewInstance();
-        pattern->SetExternalResource(styleResouce);
-        return pattern;
+        return QV4::Value::fromObject(pattern);
 
     }
-    return v8::Undefined();
+    return QV4::Value::undefinedValue();
 }
 
 // line styles
@@ -1534,48 +1737,44 @@ static v8::Handle<v8::Value> ctx2d_createPattern(const v8::Arguments &args)
     \endlist
     Other values are ignored.
 */
-v8::Handle<v8::Value> ctx2d_lineCap(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_lineCap(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
     switch (r->context->state.lineCap) {
     case Qt::RoundCap:
-        return engine->toString(QLatin1String("round"));
-    case Qt::FlatCap:
-        return engine->toString(QLatin1String("butt"));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("round")));
     case Qt::SquareCap:
-        return engine->toString(QLatin1String("square"));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("square")));
+    case Qt::FlatCap:
     default:
         break;
     }
-    return engine->toString(QLatin1String("butt"));;
+    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("butt")));
 }
 
-static void ctx2d_lineCap_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_lineCap(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-
-    QString lineCap = engine->toString(value);
+    QString lineCap = ctx->argument(0).toQString();
     Qt::PenCapStyle cap;
-    if (lineCap == QLatin1String("round"))
+    if (lineCap == QStringLiteral("round"))
         cap = Qt::RoundCap;
-    else if (lineCap == QLatin1String("butt"))
+    else if (lineCap == QStringLiteral("butt"))
         cap = Qt::FlatCap;
-    else if (lineCap == QLatin1String("square"))
+    else if (lineCap == QStringLiteral("square"))
         cap = Qt::SquareCap;
     else
-        return;
+        return QV4::Value::undefinedValue();
 
     if (cap != r->context->state.lineCap) {
         r->context->state.lineCap = cap;
         r->context->buffer()->setLineCap(cap);
     }
+    return QV4::Value::undefinedValue();
 }
 
 /*!
@@ -1592,74 +1791,70 @@ static void ctx2d_lineCap_set(v8::Local<v8::String>, v8::Local<v8::Value> value,
     \endlist
     Other values are ignored.
 */
-v8::Handle<v8::Value> ctx2d_lineJoin(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_lineJoin(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
     switch (r->context->state.lineJoin) {
     case Qt::RoundJoin:
-        return engine->toString(QLatin1String("round"));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("round")));
     case Qt::BevelJoin:
-        return engine->toString(QLatin1String("bevel"));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("bevel")));
     case Qt::MiterJoin:
-        return engine->toString(QLatin1String("miter"));
     default:
         break;
     }
-    return engine->toString(QLatin1String("miter"));
+    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("miter")));
 }
 
-static void ctx2d_lineJoin_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_lineJoin(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-
-    QString lineJoin = engine->toString(value);
+    QString lineJoin = ctx->argument(0).toQString();
     Qt::PenJoinStyle join;
-    if (lineJoin == QLatin1String("round"))
+    if (lineJoin == QStringLiteral("round"))
         join = Qt::RoundJoin;
-    else if (lineJoin == QLatin1String("bevel"))
+    else if (lineJoin == QStringLiteral("bevel"))
         join = Qt::BevelJoin;
-    else if (lineJoin == QLatin1String("miter"))
+    else if (lineJoin == QStringLiteral("miter"))
         join = Qt::SvgMiterJoin;
     else
-        return;
+        return QV4::Value::undefinedValue();
 
     if (join != r->context->state.lineJoin) {
         r->context->state.lineJoin = join;
         r->context->buffer()->setLineJoin(join);
     }
+    return QV4::Value::undefinedValue();
 }
 
 /*!
     \qmlproperty real QtQuick2::Context2D::lineWidth
      Holds the current line width. Values that are not finite values greater than zero are ignored.
  */
-v8::Handle<v8::Value> ctx2d_lineWidth(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_lineWidth(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-
-    return v8::Number::New(r->context->state.lineWidth);
+    return QV4::Value::fromDouble(r->context->state.lineWidth);
 }
 
-static void ctx2d_lineWidth_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_lineWidth(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    qreal w = value->NumberValue();
+    qreal w = ctx->argument(0).toNumber();
 
     if (w > 0 && qIsFinite(w) && w != r->context->state.lineWidth) {
         r->context->state.lineWidth = w;
         r->context->buffer()->setLineWidth(w);
     }
+    return QV4::Value::undefinedValue();
 }
 
 /*!
@@ -1667,26 +1862,26 @@ static void ctx2d_lineWidth_set(v8::Local<v8::String>, v8::Local<v8::Value> valu
      Holds the current miter limit ratio.
      The default miter limit value is 10.0.
  */
-v8::Handle<v8::Value> ctx2d_miterLimit(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_miterLimit(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-
-    return v8::Number::New(r->context->state.miterLimit);
+    return QV4::Value::fromDouble(r->context->state.miterLimit);
 }
 
-static void ctx2d_miterLimit_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_miterLimit(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    qreal ml = value->NumberValue();
+    qreal ml = ctx->argument(0).toNumber();
 
     if (ml > 0 && qIsFinite(ml) && ml != r->context->state.miterLimit) {
         r->context->state.miterLimit = ml;
         r->context->buffer()->setMiterLimit(ml);
     }
+    return QV4::Value::undefinedValue();
 }
 
 // shadows
@@ -1694,53 +1889,52 @@ static void ctx2d_miterLimit_set(v8::Local<v8::String>, v8::Local<v8::Value> val
     \qmlproperty real QtQuick2::Context2D::shadowBlur
      Holds the current level of blur applied to shadows
  */
-v8::Handle<v8::Value> ctx2d_shadowBlur(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_shadowBlur(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-
-    return v8::Number::New(r->context->state.shadowBlur);
+    return QV4::Value::fromDouble(r->context->state.shadowBlur);
 }
 
-static void ctx2d_shadowBlur_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_shadowBlur(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
-    qreal blur = value->NumberValue();
+
+    qreal blur = ctx->argument(0).toNumber();
 
     if (blur > 0 && qIsFinite(blur) && blur != r->context->state.shadowBlur) {
         r->context->state.shadowBlur = blur;
         r->context->buffer()->setShadowBlur(blur);
     }
+    return QV4::Value::undefinedValue();
 }
 
 /*!
     \qmlproperty string QtQuick2::Context2D::shadowColor
      Holds the current shadow color.
  */
-v8::Handle<v8::Value> ctx2d_shadowColor(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_shadowColor(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-
-    return engine->toString(r->context->state.shadowColor.name());
+    return QV4::Value::fromString(ctx->engine->newString(r->context->state.shadowColor.name()));
 }
 
-static void ctx2d_shadowColor_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_shadowColor(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    QColor color = qt_color_from_string(value);
+    QColor color = qt_color_from_string(ctx->argument(0));
 
     if (color.isValid() && color != r->context->state.shadowColor) {
         r->context->state.shadowColor = color;
         r->context->buffer()->setShadowColor(color);
     }
+    return QV4::Value::undefinedValue();
 }
 
 
@@ -1750,25 +1944,25 @@ static void ctx2d_shadowColor_set(v8::Local<v8::String>, v8::Local<v8::Value> va
 
      \sa shadowOffsetY
  */
-v8::Handle<v8::Value> ctx2d_shadowOffsetX(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_shadowOffsetX(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-
-    return v8::Number::New(r->context->state.shadowOffsetX);
+    return QV4::Value::fromDouble(r->context->state.shadowOffsetX);
 }
 
-static void ctx2d_shadowOffsetX_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_shadowOffsetX(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    qreal offsetX = value->NumberValue();
+    qreal offsetX = ctx->argument(0).toNumber();
     if (qIsFinite(offsetX) && offsetX != r->context->state.shadowOffsetX) {
         r->context->state.shadowOffsetX = offsetX;
         r->context->buffer()->setShadowOffsetX(offsetX);
     }
+    return QV4::Value::undefinedValue();
 }
 /*!
     \qmlproperty qreal QtQuick2::Context2D::shadowOffsetY
@@ -1776,50 +1970,51 @@ static void ctx2d_shadowOffsetX_set(v8::Local<v8::String>, v8::Local<v8::Value>
 
      \sa shadowOffsetX
  */
-v8::Handle<v8::Value> ctx2d_shadowOffsetY(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_shadowOffsetY(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-
-    return v8::Number::New(r->context->state.shadowOffsetY);
+    return QV4::Value::fromDouble(r->context->state.shadowOffsetY);
 }
 
-static void ctx2d_shadowOffsetY_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_shadowOffsetY(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    qreal offsetY = value->NumberValue();
+    qreal offsetY = ctx->argument(0).toNumber();
     if (qIsFinite(offsetY) && offsetY != r->context->state.shadowOffsetY) {
         r->context->state.shadowOffsetY = offsetY;
         r->context->buffer()->setShadowOffsetY(offsetY);
     }
+    return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> ctx2d_path(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_path(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
-    return r->context->m_v8path;
+
+    return r->context->m_v4path.value();
 }
 
-static void ctx2d_path_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_path(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
 
+    QV4::Value value = ctx->argument(0);
     r->context->beginPath();
-    if (value->IsObject()) {
-        QQuickPath* path = qobject_cast<QQuickPath*>(engine->toQObject(value));
-        if (path)
+    if (QV4::QObjectWrapper *qobjectWrapper = value.as<QV4::QObjectWrapper>()) {
+        if (QQuickPath *path = qobject_cast<QQuickPath*>(qobjectWrapper->object()))
             r->context->m_path = path->path();
     } else {
-        QString path = engine->toString(value->ToString());
+        QString path = value.toQString();
         QQuickSvgParser::parsePathDataFast(path, r->context->m_path);
     }
-    r->context->m_v8path = value;
+    r->context->m_v4path = value;
+    return QV4::Value::undefinedValue();
 }
 
 //rects
@@ -1827,19 +2022,19 @@ static void ctx2d_path_set(v8::Local<v8::String>, v8::Local<v8::Value> value, co
   \qmlmethod object QtQuick2::Context2D::clearRect(real x, real y, real w, real h)
   Clears all pixels on the canvas in the given rectangle to transparent black.
   */
-static v8::Handle<v8::Value> ctx2d_clearRect(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_clearRect(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    if (args.Length() == 4)
-        r->context->clearRect(args[0]->NumberValue(),
-                              args[1]->NumberValue(),
-                              args[2]->NumberValue(),
-                              args[3]->NumberValue());
+    if (ctx->argumentCount == 4)
+        r->context->clearRect(ctx->arguments[0].toNumber(),
+                              ctx->arguments[1].toNumber(),
+                              ctx->arguments[2].toNumber(),
+                              ctx->arguments[3].toNumber());
 
-    return args.This();
+    return ctx->thisObject;
 }
 /*!
   \qmlmethod object QtQuick2::Context2D::fillRect(real x, real y, real w, real h)
@@ -1847,14 +2042,14 @@ static v8::Handle<v8::Value> ctx2d_clearRect(const v8::Arguments &args)
 
    \sa fillStyle
   */
-static v8::Handle<v8::Value> ctx2d_fillRect(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_fillRect(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    if (args.Length() == 4)
-        r->context->fillRect(args[0]->NumberValue(), args[1]->NumberValue(), args[2]->NumberValue(), args[3]->NumberValue());
-    return args.This();
+    if (ctx->argumentCount == 4)
+        r->context->fillRect(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber(), ctx->arguments[2].toNumber(), ctx->arguments[3].toNumber());
+    return ctx->thisObject;
 }
 
 /*!
@@ -1867,15 +2062,15 @@ static v8::Handle<v8::Value> ctx2d_fillRect(const v8::Arguments &args)
    \sa lineJoin
    \sa miterLimit
   */
-static v8::Handle<v8::Value> ctx2d_strokeRect(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_strokeRect(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    if (args.Length() == 4)
-        r->context->strokeRect(args[0]->NumberValue(), args[1]->NumberValue(), args[2]->NumberValue(), args[3]->NumberValue());
+    if (ctx->argumentCount == 4)
+        r->context->strokeRect(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber(), ctx->arguments[2].toNumber(), ctx->arguments[3].toNumber());
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 // Complex shapes (paths) API
@@ -1899,31 +2094,31 @@ static v8::Handle<v8::Value> ctx2d_strokeRect(const v8::Arguments &args)
     \sa arcTo, {http://www.w3.org/TR/2dcontext/#dom-context-2d-arc}{W3C's 2D
     Context Standard for arc()}
 */
-static v8::Handle<v8::Value> ctx2d_arc(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_arc(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    if (args.Length() >= 5) {
+    if (ctx->argumentCount >= 5) {
         bool antiClockwise = false;
 
-        if (args.Length() == 6)
-            antiClockwise = args[5]->BooleanValue();
+        if (ctx->argumentCount == 6)
+            antiClockwise = ctx->arguments[5].toBoolean();
 
-        qreal radius = args[2]->NumberValue();
+        qreal radius = ctx->arguments[2].toNumber();
 
         if (qIsFinite(radius) && radius < 0)
-           V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "Incorrect argument radius");
+           V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "Incorrect argument radius");
 
-        r->context->arc(args[0]->NumberValue(),
-                        args[1]->NumberValue(),
+        r->context->arc(ctx->arguments[0].toNumber(),
+                        ctx->arguments[1].toNumber(),
                         radius,
-                        args[3]->NumberValue(),
-                        args[4]->NumberValue(),
+                        ctx->arguments[3].toNumber(),
+                        ctx->arguments[4].toNumber(),
                         antiClockwise);
     }
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -1949,25 +2144,25 @@ static v8::Handle<v8::Value> ctx2d_arc(const v8::Arguments &args)
     \sa arc, {http://www.w3.org/TR/2dcontext/#dom-context-2d-arcto}{W3C's 2D
     Context Standard for arcTo()}
 */
-static v8::Handle<v8::Value> ctx2d_arcTo(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_arcTo(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    if (args.Length() == 5) {
-        qreal radius = args[4]->NumberValue();
+    if (ctx->argumentCount == 5) {
+        qreal radius = ctx->arguments[4].toNumber();
 
         if (qIsFinite(radius) && radius < 0)
-           V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "Incorrect argument radius");
+           V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "Incorrect argument radius");
 
-        r->context->arcTo(args[0]->NumberValue(),
-                          args[1]->NumberValue(),
-                          args[2]->NumberValue(),
-                          args[3]->NumberValue(),
+        r->context->arcTo(ctx->arguments[0].toNumber(),
+                          ctx->arguments[1].toNumber(),
+                          ctx->arguments[2].toNumber(),
+                          ctx->arguments[3].toNumber(),
                           radius);
     }
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -1975,15 +2170,15 @@ static v8::Handle<v8::Value> ctx2d_arcTo(const v8::Arguments &args)
 
    Resets the current path to a new path.
   */
-static v8::Handle<v8::Value> ctx2d_beginPath(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_beginPath(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
     r->context->beginPath();
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2005,27 +2200,27 @@ static v8::Handle<v8::Value> ctx2d_beginPath(const v8::Arguments &args)
   \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-beziercurveto}{W3C 2d context standard for bezierCurveTo}
   \sa {http://www.openrise.com/lab/FlowerPower/}{The beautiful flower demo by using bezierCurveTo}
   */
-static v8::Handle<v8::Value> ctx2d_bezierCurveTo(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_bezierCurveTo(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    if (args.Length() == 6) {
-        qreal cp1x = args[0]->NumberValue();
-        qreal cp1y = args[1]->NumberValue();
-        qreal cp2x = args[2]->NumberValue();
-        qreal cp2y = args[3]->NumberValue();
-        qreal x = args[4]->NumberValue();
-        qreal y = args[5]->NumberValue();
+    if (ctx->argumentCount == 6) {
+        qreal cp1x = ctx->arguments[0].toNumber();
+        qreal cp1y = ctx->arguments[1].toNumber();
+        qreal cp2x = ctx->arguments[2].toNumber();
+        qreal cp2y = ctx->arguments[3].toNumber();
+        qreal x = ctx->arguments[4].toNumber();
+        qreal y = ctx->arguments[5].toNumber();
 
         if (!qIsFinite(cp1x) || !qIsFinite(cp1y) || !qIsFinite(cp2x) || !qIsFinite(cp2y) || !qIsFinite(x) || !qIsFinite(y))
-            return args.This();
+            return ctx->thisObject;
 
         r->context->bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
     }
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2052,13 +2247,13 @@ static v8::Handle<v8::Value> ctx2d_bezierCurveTo(const v8::Arguments &args)
     \sa fill()
    \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-clip}{W3C 2d context standard for clip}
   */
-static v8::Handle<v8::Value> ctx2d_clip(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_clip(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->clip();
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2068,15 +2263,15 @@ static v8::Handle<v8::Value> ctx2d_clip(const v8::Arguments &args)
 
    \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-closepath}{W3C 2d context standard for closePath}
   */
-static v8::Handle<v8::Value> ctx2d_closePath(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_closePath(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
     r->context->closePath();
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2088,12 +2283,12 @@ static v8::Handle<v8::Value> ctx2d_closePath(const v8::Arguments &args)
 
    \sa fillStyle
   */
-static v8::Handle<v8::Value> ctx2d_fill(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_fill(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r);
     r->context->fill();
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2101,23 +2296,23 @@ static v8::Handle<v8::Value> ctx2d_fill(const v8::Arguments &args)
 
    Draws a line from the current position to the point (x, y).
  */
-static v8::Handle<v8::Value> ctx2d_lineTo(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_lineTo(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    if (args.Length() == 2) {
-        qreal x = args[0]->NumberValue();
-        qreal y = args[1]->NumberValue();
+    if (ctx->argumentCount == 2) {
+        qreal x = ctx->arguments[0].toNumber();
+        qreal y = ctx->arguments[1].toNumber();
 
         if (!qIsFinite(x) || !qIsFinite(y))
-            return args.This();
+            return ctx->thisObject;
 
         r->context->lineTo(x, y);
     }
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2125,20 +2320,20 @@ static v8::Handle<v8::Value> ctx2d_lineTo(const v8::Arguments &args)
 
    Creates a new subpath with the given point.
  */
-static v8::Handle<v8::Value> ctx2d_moveTo(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_moveTo(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    if (args.Length() == 2) {
-        qreal x = args[0]->NumberValue();
-        qreal y = args[1]->NumberValue();
+    if (ctx->argumentCount == 2) {
+        qreal x = ctx->arguments[0].toNumber();
+        qreal y = ctx->arguments[1].toNumber();
 
         if (!qIsFinite(x) || !qIsFinite(y))
-            return args.This();
+            return ctx->thisObject;
         r->context->moveTo(x, y);
     }
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2148,24 +2343,24 @@ static v8::Handle<v8::Value> ctx2d_moveTo(const v8::Arguments &args)
 
    See \l{http://www.w3.org/TR/2dcontext/#dom-context-2d-quadraticcurveto}{W3C 2d context standard for  for quadraticCurveTo}
  */
-static v8::Handle<v8::Value> ctx2d_quadraticCurveTo(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_quadraticCurveTo(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    if (args.Length() == 4) {
-        qreal cpx = args[0]->NumberValue();
-        qreal cpy = args[1]->NumberValue();
-        qreal x = args[2]->NumberValue();
-        qreal y = args[3]->NumberValue();
+    if (ctx->argumentCount == 4) {
+        qreal cpx = ctx->arguments[0].toNumber();
+        qreal cpy = ctx->arguments[1].toNumber();
+        qreal x = ctx->arguments[2].toNumber();
+        qreal y = ctx->arguments[3].toNumber();
 
         if (!qIsFinite(cpx) || !qIsFinite(cpy) || !qIsFinite(x) || !qIsFinite(y))
-            return args.This();
+            return ctx->thisObject;
 
         r->context->quadraticCurveTo(cpx, cpy, x, y);
     }
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2173,14 +2368,14 @@ static v8::Handle<v8::Value> ctx2d_quadraticCurveTo(const v8::Arguments &args)
 
    Adds a rectangle at position (\c x, \c y), with the given width \c w and height \c h, as a closed subpath.
  */
-static v8::Handle<v8::Value> ctx2d_rect(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_rect(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    if (args.Length() == 4)
-        r->context->rect(args[0]->NumberValue(), args[1]->NumberValue(), args[2]->NumberValue(), args[3]->NumberValue());
-    return args.This();
+    if (ctx->argumentCount == 4)
+        r->context->rect(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber(), ctx->arguments[2].toNumber(), ctx->arguments[3].toNumber());
+    return ctx->thisObject;
 }
 
 /*!
@@ -2189,19 +2384,19 @@ static v8::Handle<v8::Value> ctx2d_rect(const v8::Arguments &args)
    Adds the given rectangle rect with rounded corners to the path. The \c xRadius and \c yRadius arguments specify the radius of the
    ellipses defining the corners of the rounded rectangle.
  */
-static v8::Handle<v8::Value> ctx2d_roundedRect(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_roundedRect(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    if (args.Length() == 6)
-        r->context->roundedRect(args[0]->NumberValue()
-                              , args[1]->NumberValue()
-                              , args[2]->NumberValue()
-                              , args[3]->NumberValue()
-                              , args[4]->NumberValue()
-                              , args[5]->NumberValue());
-    return args.This();
+    if (ctx->argumentCount == 6)
+        r->context->roundedRect(ctx->arguments[0].toNumber()
+                              , ctx->arguments[1].toNumber()
+                              , ctx->arguments[2].toNumber()
+                              , ctx->arguments[3].toNumber()
+                              , ctx->arguments[4].toNumber()
+                              , ctx->arguments[5].toNumber());
+    return ctx->thisObject;
 }
 
 /*!
@@ -2212,16 +2407,16 @@ static v8::Handle<v8::Value> ctx2d_roundedRect(const v8::Arguments &args)
 
   The ellipse is composed of a clockwise curve, starting and finishing at zero degrees (the 3 o'clock position).
  */
-static v8::Handle<v8::Value> ctx2d_ellipse(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_ellipse(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
 
-    if (args.Length() == 4)
-        r->context->ellipse(args[0]->NumberValue(), args[1]->NumberValue(), args[2]->NumberValue(), args[3]->NumberValue());
+    if (ctx->argumentCount == 4)
+        r->context->ellipse(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber(), ctx->arguments[2].toNumber(), ctx->arguments[3].toNumber());
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2230,21 +2425,20 @@ static v8::Handle<v8::Value> ctx2d_ellipse(const v8::Arguments &args)
   Adds the given \c text to the path as a set of closed subpaths created from the current context font supplied.
   The subpaths are positioned so that the left end of the text's baseline lies at the point specified by (\c x, \c y).
  */
-static v8::Handle<v8::Value> ctx2d_text(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_text(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE();
-    if (args.Length() == 3) {
-        qreal x = args[1]->NumberValue();
-        qreal y = args[2]->NumberValue();
+    if (ctx->argumentCount == 3) {
+        qreal x = ctx->arguments[1].toNumber();
+        qreal y = ctx->arguments[2].toNumber();
 
         if (!qIsFinite(x) || !qIsFinite(y))
-            return args.This();
-        r->context->text(engine->toString(args[0]), x, y);
+            return ctx->thisObject;
+        r->context->text(ctx->arguments[0].toQString(), x, y);
     }
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2256,13 +2450,13 @@ static v8::Handle<v8::Value> ctx2d_text(const v8::Arguments &args)
 
    \sa strokeStyle
   */
-static v8::Handle<v8::Value> ctx2d_stroke(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_stroke(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     r->context->stroke();
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -2272,36 +2466,36 @@ static v8::Handle<v8::Value> ctx2d_stroke(const v8::Arguments &args)
 
    \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-ispointinpath}{W3C 2d context standard for isPointInPath}
   */
-static v8::Handle<v8::Value> ctx2d_isPointInPath(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_isPointInPath(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
     bool pointInPath = false;
-    if (args.Length() == 2)
-        pointInPath = r->context->isPointInPath(args[0]->NumberValue(), args[1]->NumberValue());
-    return v8::Boolean::New(pointInPath);
+    if (ctx->argumentCount == 2)
+        pointInPath = r->context->isPointInPath(ctx->arguments[0].toNumber(), ctx->arguments[1].toNumber());
+    return QV4::Value::fromBoolean(pointInPath);
 }
 
-static v8::Handle<v8::Value> ctx2d_drawFocusRing(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_drawFocusRing(QV4::SimpleCallContext *ctx)
 {
-    Q_UNUSED(args);
+    Q_UNUSED(ctx);
 
-    V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::drawFocusRing is not supported");
+    V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::drawFocusRing is not supported");
 }
 
-static v8::Handle<v8::Value> ctx2d_setCaretSelectionRect(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_setCaretSelectionRect(QV4::SimpleCallContext *ctx)
 {
-    Q_UNUSED(args);
+    Q_UNUSED(ctx);
 
-    V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::setCaretSelectionRect is not supported");
+    V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::setCaretSelectionRect is not supported");
 }
 
-static v8::Handle<v8::Value> ctx2d_caretBlinkRate(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_caretBlinkRate(QV4::SimpleCallContext *ctx)
 {
-    Q_UNUSED(args);
+    Q_UNUSED(ctx);
 
-    V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::caretBlinkRate is not supported");
+    V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::caretBlinkRate is not supported");
 }
 
 /*!
@@ -2327,27 +2521,25 @@ static v8::Handle<v8::Value> ctx2d_caretBlinkRate(const v8::Arguments &args)
 
     The default font value is "10px sans-serif".
   */
-v8::Handle<v8::Value> ctx2d_font(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_font(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-
-    return engine->toString(r->context->state.font.toString());
+    return QV4::Value::fromString(ctx->engine->newString(r->context->state.font.toString()));
 }
 
-static void ctx2d_font_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_font(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-    QString fs = engine->toString(value);
+    QString fs = ctx->argument(0).toQString();
     QFont font = qt_font_from_string(fs, r->context->state.font);
     if (font != r->context->state.font) {
         r->context->state.font = font;
     }
+    return QV4::Value::undefinedValue();
 }
 
 /*!
@@ -2364,53 +2556,52 @@ static void ctx2d_font_set(v8::Local<v8::String>, v8::Local<v8::Value> value, co
   \endlist
   Other values are ignored. The default value is "start".
   */
-v8::Handle<v8::Value> ctx2d_textAlign(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_textAlign(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
+
     switch (r->context->state.textAlign) {
+    case QQuickContext2D::End:
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("end")));
+    case QQuickContext2D::Left:
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("left")));
+    case QQuickContext2D::Right:
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("right")));
+    case QQuickContext2D::Center:
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("center")));
     case QQuickContext2D::Start:
-        return engine->toString(QLatin1String("start"));
-   case QQuickContext2D::End:
-        return engine->toString(QLatin1String("end"));
-   case QQuickContext2D::Left:
-        return engine->toString(QLatin1String("left"));
-   case QQuickContext2D::Right:
-        return engine->toString(QLatin1String("right"));
-   case QQuickContext2D::Center:
-        return engine->toString(QLatin1String("center"));
     default:
         break;
     }
-    return engine->toString(QLatin1String("start"));
+    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("start")));
 }
 
-static void ctx2d_textAlign_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_textAlign(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
 
-    QString textAlign = engine->toString(value);
+    QString textAlign = ctx->argument(0).toQString();
 
     QQuickContext2D::TextAlignType ta;
-    if (textAlign == QLatin1String("start"))
+    if (textAlign == QStringLiteral("start"))
         ta = QQuickContext2D::Start;
-    else if (textAlign == QLatin1String("end"))
+    else if (textAlign == QStringLiteral("end"))
         ta = QQuickContext2D::End;
-    else if (textAlign == QLatin1String("left"))
+    else if (textAlign == QStringLiteral("left"))
         ta = QQuickContext2D::Left;
-    else if (textAlign == QLatin1String("right"))
+    else if (textAlign == QStringLiteral("right"))
         ta = QQuickContext2D::Right;
-    else if (textAlign == QLatin1String("center"))
+    else if (textAlign == QStringLiteral("center"))
         ta = QQuickContext2D::Center;
     else
-        return;
+        return QV4::Value::undefinedValue();
 
-    if (ta != r->context->state.textAlign) {
+    if (ta != r->context->state.textAlign)
         r->context->state.textAlign = ta;
-    }
+
+    return QV4::Value::undefinedValue();
 }
 
 /*!
@@ -2428,53 +2619,51 @@ static void ctx2d_textAlign_set(v8::Local<v8::String>, v8::Local<v8::Value> valu
   \endlist
   Other values are ignored. The default value is "alphabetic".
   */
-v8::Handle<v8::Value> ctx2d_textBaseline(v8::Local<v8::String>, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_get_textBaseline(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
     switch (r->context->state.textBaseline) {
-    case QQuickContext2D::Alphabetic:
-        return engine->toString(QLatin1String("alphabetic"));
     case QQuickContext2D::Hanging:
-        return engine->toString(QLatin1String("hanging"));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("hanging")));
     case QQuickContext2D::Top:
-        return engine->toString(QLatin1String("top"));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("top")));
     case QQuickContext2D::Bottom:
-        return engine->toString(QLatin1String("bottom"));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("bottom")));
     case QQuickContext2D::Middle:
-        return engine->toString(QLatin1String("middle"));
+        return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("middle")));
+    case QQuickContext2D::Alphabetic:
     default:
         break;
     }
-    return engine->toString(QLatin1String("alphabetic"));
+    return QV4::Value::fromString(ctx->engine->newString(QStringLiteral("alphabetic")));
 }
 
-static void ctx2d_textBaseline_set(v8::Local<v8::String>, v8::Local<v8::Value> value, const v8::AccessorInfo &info)
+QV4::Value QQuickJSContext2D::method_set_textBaseline(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(info.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT_SETTER(r)
-    QV8Engine *engine = V8ENGINE_ACCESSOR();
-    QString textBaseline = engine->toString(value);
+    QString textBaseline = ctx->argument(0).toQString();
 
     QQuickContext2D::TextBaseLineType tb;
-    if (textBaseline == QLatin1String("alphabetic"))
+    if (textBaseline == QStringLiteral("alphabetic"))
         tb = QQuickContext2D::Alphabetic;
-    else if (textBaseline == QLatin1String("hanging"))
+    else if (textBaseline == QStringLiteral("hanging"))
         tb = QQuickContext2D::Hanging;
-    else if (textBaseline == QLatin1String("top"))
+    else if (textBaseline == QStringLiteral("top"))
         tb = QQuickContext2D::Top;
-    else if (textBaseline == QLatin1String("bottom"))
+    else if (textBaseline == QStringLiteral("bottom"))
         tb = QQuickContext2D::Bottom;
-    else if (textBaseline == QLatin1String("middle"))
+    else if (textBaseline == QStringLiteral("middle"))
         tb = QQuickContext2D::Middle;
     else
-        return;
+        return QV4::Value::undefinedValue();
 
-    if (tb != r->context->state.textBaseline) {
+    if (tb != r->context->state.textBaseline)
         r->context->state.textBaseline = tb;
-    }
+
+    return QV4::Value::undefinedValue();
 }
 
 /*!
@@ -2485,21 +2674,20 @@ static void ctx2d_textBaseline_set(v8::Local<v8::String>, v8::Local<v8::Value> v
   \sa textBaseline
   \sa strokeText
   */
-static v8::Handle<v8::Value> ctx2d_fillText(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_fillText(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE();
-    if (args.Length() == 3) {
-        qreal x = args[1]->NumberValue();
-        qreal y = args[2]->NumberValue();
+    if (ctx->argumentCount == 3) {
+        qreal x = ctx->arguments[1].toNumber();
+        qreal y = ctx->arguments[2].toNumber();
         if (!qIsFinite(x) || !qIsFinite(y))
-            return args.This();
-        QPainterPath textPath = r->context->createTextGlyphs(x, y, engine->toString(args[0]));
+            return ctx->thisObject;
+        QPainterPath textPath = r->context->createTextGlyphs(x, y, ctx->arguments[0].toQString());
         r->context->buffer()->fill(textPath);
     }
-    return args.This();
+    return ctx->thisObject;
 }
 /*!
   \qmlmethod object QtQuick2::Context2D::strokeText(text, x, y)
@@ -2509,15 +2697,14 @@ static v8::Handle<v8::Value> ctx2d_fillText(const v8::Arguments &args)
   \sa textBaseline
   \sa fillText
   */
-static v8::Handle<v8::Value> ctx2d_strokeText(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_strokeText(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE();
-    if (args.Length() == 3)
-        r->context->drawText(engine->toString(args[0]), args[1]->NumberValue(), args[2]->NumberValue(), false);
-    return args.This();
+    if (ctx->argumentCount == 3)
+        r->context->drawText(ctx->arguments[0].toQString(), ctx->arguments[1].toNumber(), ctx->arguments[2].toNumber(), false);
+    return ctx->thisObject;
 }
 
 /*!
@@ -2544,21 +2731,19 @@ static v8::Handle<v8::Value> ctx2d_strokeText(const v8::Arguments &args)
   \qmlmethod variant QtQuick2::Context2D::measureText(text)
   Returns a TextMetrics object with the metrics of the given text in the current font.
   */
-static v8::Handle<v8::Value> ctx2d_measureText(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_measureText(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE();
-
-    if (args.Length() == 1) {
+    if (ctx->argumentCount == 1) {
         QFontMetrics fm(r->context->state.font);
-        uint width = fm.width(engine->toString(args[0]));
-        v8::Local<v8::Object> tm = v8::Object::New();
-        tm->Set(v8::String::New("width"), v8::Number::New(width));
-        return tm;
+        uint width = fm.width(ctx->arguments[0].toQString());
+        QV4::Object *tm = ctx->engine->newObject();
+        tm->put(ctx->engine->newIdentifier(QStringLiteral("width")), QV4::Value::fromDouble(width));
+        return QV4::Value::fromObject(tm);
     }
-    return v8::Undefined();
+    return QV4::Value::undefinedValue();
 }
 
 // drawing images
@@ -2620,84 +2805,89 @@ static v8::Handle<v8::Value> ctx2d_measureText(const v8::Arguments &args)
 
   \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-drawimage}{W3C 2d context standard for drawImage}
 */
-static v8::Handle<v8::Value> ctx2d_drawImage(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_drawImage(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE();
     qreal sx, sy, sw, sh, dx, dy, dw, dh;
 
-    if (!args.Length())
-        return args.This();
+    if (!ctx->argumentCount)
+        return ctx->thisObject;
 
     //FIXME:This function should be moved to QQuickContext2D::drawImage(...)
     if (!r->context->state.invertibleCTM)
-        return args.This();
+        return ctx->thisObject;
 
     QQmlRefPointer<QQuickCanvasPixmap> pixmap;
 
-    if (args[0]->IsString()) {
-        QUrl url(engine->toString(args[0]->ToString()));
+    if (ctx->arguments[0].isString()) {
+        QUrl url(ctx->arguments[0].toQString());
         if (!url.isValid())
-            V8THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
+            V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
 
         pixmap = r->context->createPixmap(url);
-    } else if (args[0]->IsObject()) {
-        QQuickImage *imageItem = qobject_cast<QQuickImage*>(engine->toQObject(args[0]->ToObject()));
-        QQuickCanvasItem *canvas = qobject_cast<QQuickCanvasItem*>(engine->toQObject(args[0]->ToObject()));
-        QUrl url(engine->toString(args[0]));
-
-        QV8Context2DPixelArrayResource *pix = v8_resource_cast<QV8Context2DPixelArrayResource>(args[0]->ToObject()->GetInternalField(0)->ToObject());
-        if (pix && !pix->image.isNull()) {
-            pixmap.take(new QQuickCanvasPixmap(pix->image, r->context->canvas()->window()));
-        } else if (imageItem) {
-            pixmap.take(r->context->createPixmap(imageItem->source()));
-        } else if (canvas) {
-            QImage img = canvas->toImage();
-            if (!img.isNull())
-                pixmap.take(new QQuickCanvasPixmap(img, canvas->window()));
-        } else if (url.isValid()) {
-            pixmap = r->context->createPixmap(url);
+    } else if (ctx->arguments[0].isObject()) {
+        if (QV4::QObjectWrapper *qobjectWrapper = ctx->arguments[0].as<QV4::QObjectWrapper>()) {
+            if (QQuickImage *imageItem = qobject_cast<QQuickImage*>(qobjectWrapper->object())) {
+                pixmap.take(r->context->createPixmap(imageItem->source()));
+            } else if (QQuickCanvasItem *canvas = qobject_cast<QQuickCanvasItem*>(qobjectWrapper->object())) {
+                QImage img = canvas->toImage();
+                if (!img.isNull())
+                    pixmap.take(new QQuickCanvasPixmap(img, canvas->window()));
+            } else {
+                V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
+            }
+        } else if (QQuickJSContext2DImageData *imageData = ctx->arguments[0].as<QQuickJSContext2DImageData>()) {
+            QQuickJSContext2DPixelData *pix = imageData->pixelData.as<QQuickJSContext2DPixelData>();
+            if (pix && !pix->image.isNull()) {
+                pixmap.take(new QQuickCanvasPixmap(pix->image, r->context->canvas()->window()));
+            } else {
+                V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
+            }
         } else {
-            V8THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
+            QUrl url(ctx->arguments[0].toQString());
+            if (url.isValid())
+                pixmap = r->context->createPixmap(url);
+            else
+                V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
         }
     } else {
-        V8THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
+        V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
     }
 
     if (pixmap.isNull() || !pixmap->isValid())
-        return args.This();
+        return ctx->thisObject;
 
-    if (args.Length() == 3) {
-        dx = args[1]->NumberValue();
-        dy = args[2]->NumberValue();
+    if (ctx->argumentCount == 3) {
+        dx = ctx->arguments[1].toNumber();
+        dy = ctx->arguments[2].toNumber();
         sx = 0;
         sy = 0;
         sw = pixmap->width();
         sh = pixmap->height();
         dw = sw;
         dh = sh;
-    } else if (args.Length() == 5) {
+    } else if (ctx->argumentCount == 5) {
         sx = 0;
         sy = 0;
         sw = pixmap->width();
         sh = pixmap->height();
-        dx = args[1]->NumberValue();
-        dy = args[2]->NumberValue();
-        dw = args[3]->NumberValue();
-        dh = args[4]->NumberValue();
-    } else if (args.Length() == 9) {
-        sx = args[1]->NumberValue();
-        sy = args[2]->NumberValue();
-        sw = args[3]->NumberValue();
-        sh = args[4]->NumberValue();
-        dx = args[5]->NumberValue();
-        dy = args[6]->NumberValue();
-        dw = args[7]->NumberValue();
-        dh = args[8]->NumberValue();
+        dx = ctx->arguments[1].toNumber();
+        dy = ctx->arguments[2].toNumber();
+        dw = ctx->arguments[3].toNumber();
+        dh = ctx->arguments[4].toNumber();
+    } else if (ctx->argumentCount == 9) {
+        sx = ctx->arguments[1].toNumber();
+        sy = ctx->arguments[2].toNumber();
+        sw = ctx->arguments[3].toNumber();
+        sh = ctx->arguments[4].toNumber();
+        dx = ctx->arguments[5].toNumber();
+        dy = ctx->arguments[6].toNumber();
+        dw = ctx->arguments[7].toNumber();
+        dh = ctx->arguments[8].toNumber();
     } else {
-        return args.This();
+        return ctx->thisObject;
     }
 
     if (!qIsFinite(sx)
@@ -2708,7 +2898,7 @@ static v8::Handle<v8::Value> ctx2d_drawImage(const v8::Arguments &args)
      || !qIsFinite(dy)
      || !qIsFinite(dw)
      || !qIsFinite(dh))
-        return args.This();
+        return ctx->thisObject;
 
     if (sx < 0
     || sy < 0
@@ -2717,12 +2907,12 @@ static v8::Handle<v8::Value> ctx2d_drawImage(const v8::Arguments &args)
     || sx + sw > pixmap->width()
     || sy + sh > pixmap->height()
     || sx + sw < 0 || sy + sh < 0) {
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "drawImage(), index size error");
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "drawImage(), index size error");
     }
 
     r->context->buffer()->drawPixmap(pixmap, QRectF(sx, sy, sw, sh), QRectF(dx, dy, dw, dh));
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 // pixel manipulation
@@ -2749,34 +2939,42 @@ static v8::Handle<v8::Value> ctx2d_drawImage(const v8::Arguments &args)
   \qmlproperty int QtQuick2::CanvasImageData::width
   Holds the actual width dimension of the data in the ImageData object, in device pixels.
  */
-v8::Handle<v8::Value> ctx2d_imageData_width(v8::Local<v8::String>, const v8::AccessorInfo &args)
+QV4::Value QQuickJSContext2DImageData::method_get_width(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DPixelArrayResource *r = v8_resource_cast<QV8Context2DPixelArrayResource>(args.This()->GetInternalField(0)->ToObject());
+    QQuickJSContext2DImageData *imageData = ctx->thisObject.as<QQuickJSContext2DImageData>();
+    if (!imageData)
+        ctx->throwTypeError();
+    QQuickJSContext2DPixelData *r = imageData->pixelData.as<QQuickJSContext2DPixelData>();
     if (!r)
-        return v8::Integer::New(0);
-    return v8::Integer::New(r->image.width());
+        return QV4::Value::fromInt32(0);
+    return QV4::Value::fromInt32(r->image.width());
 }
 
 /*!
   \qmlproperty int QtQuick2::CanvasImageData::height
   Holds the actual height dimension of the data in the ImageData object, in device pixels.
   */
-v8::Handle<v8::Value> ctx2d_imageData_height(v8::Local<v8::String>, const v8::AccessorInfo &args)
+QV4::Value QQuickJSContext2DImageData::method_get_height(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DPixelArrayResource *r = v8_resource_cast<QV8Context2DPixelArrayResource>(args.This()->GetInternalField(0)->ToObject());
+    QQuickJSContext2DImageData *imageData = ctx->thisObject.as<QQuickJSContext2DImageData>();
+    if (!imageData)
+        ctx->throwTypeError();
+    QQuickJSContext2DPixelData *r = imageData->pixelData.as<QQuickJSContext2DPixelData>();
     if (!r)
-        return v8::Integer::New(0);
-
-    return v8::Integer::New(r->image.height());
+        return QV4::Value::fromInt32(0);
+    return QV4::Value::fromInt32(r->image.height());
 }
 
 /*!
   \qmlproperty object QtQuick2::CanvasImageData::data
   Holds the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
  */
-v8::Handle<v8::Value> ctx2d_imageData_data(v8::Local<v8::String>, const v8::AccessorInfo &args)
+QV4::Value QQuickJSContext2DImageData::method_get_data(QV4::SimpleCallContext *ctx)
 {
-    return args.This()->GetInternalField(0);
+    QQuickJSContext2DImageData *imageData = ctx->thisObject.as<QQuickJSContext2DImageData>();
+    if (!imageData)
+        ctx->throwTypeError();
+    return imageData->pixelData;
 }
 
 /*!
@@ -2797,19 +2995,24 @@ v8::Handle<v8::Value> ctx2d_imageData_data(v8::Local<v8::String>, const v8::Acce
   The length attribute of a CanvasPixelArray object must return this h×w×4 number value.
   This property is read only.
 */
-v8::Handle<v8::Value> ctx2d_pixelArray_length(v8::Local<v8::String>, const v8::AccessorInfo &args)
+QV4::Value QQuickJSContext2DPixelData::proto_get_length(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DPixelArrayResource *r = v8_resource_cast<QV8Context2DPixelArrayResource>(args.This());
-    if (!r || r->image.isNull()) return v8::Undefined();
+    QQuickJSContext2DPixelData *r = ctx->thisObject.as<QQuickJSContext2DPixelData>();
+    if (!r || r->image.isNull())
+        return QV4::Value::undefinedValue();
 
-    return v8::Integer::New(r->image.width() * r->image.height() * 4);
+    return QV4::Value::fromInt32(r->image.width() * r->image.height() * 4);
 }
 
-v8::Handle<v8::Value> ctx2d_pixelArray_indexed(uint32_t index, const v8::AccessorInfo& args)
+QV4::Value QQuickJSContext2DPixelData::getIndexed(QV4::Managed *m, uint index, bool *hasProperty)
 {
-    QV8Context2DPixelArrayResource *r = v8_resource_cast<QV8Context2DPixelArrayResource>(args.This());
+    QQuickJSContext2DPixelData *r = m->as<QQuickJSContext2DPixelData>();
+    if (!m)
+        m->engine()->current->throwTypeError();
 
     if (r && index < static_cast<quint32>(r->image.width() * r->image.height() * 4)) {
+        if (hasProperty)
+            *hasProperty = true;
         const quint32 w = r->image.width();
         const quint32 row = (index / 4) / w;
         const quint32 col = (index / 4) % w;
@@ -2817,23 +3020,27 @@ v8::Handle<v8::Value> ctx2d_pixelArray_indexed(uint32_t index, const v8::Accesso
         pixel += col;
         switch (index % 4) {
         case 0:
-            return v8::Integer::New(qRed(*pixel));
+            return QV4::Value::fromInt32(qRed(*pixel));
         case 1:
-            return v8::Integer::New(qGreen(*pixel));
+            return QV4::Value::fromInt32(qGreen(*pixel));
         case 2:
-            return v8::Integer::New(qBlue(*pixel));
+            return QV4::Value::fromInt32(qBlue(*pixel));
         case 3:
-            return v8::Integer::New(qAlpha(*pixel));
+            return QV4::Value::fromInt32(qAlpha(*pixel));
         }
     }
-    return v8::Undefined();
+    if (hasProperty)
+        *hasProperty = false;
+    return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> ctx2d_pixelArray_indexed_set(uint32_t index, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+void QQuickJSContext2DPixelData::putIndexed(QV4::Managed *m, uint index, const QV4::Value &value)
 {
-    QV8Context2DPixelArrayResource *r = v8_resource_cast<QV8Context2DPixelArrayResource>(info.This());
+    QQuickJSContext2DPixelData *r = m->as<QQuickJSContext2DPixelData>();
+    if (!r)
+        m->engine()->current->throwTypeError();
 
-    const int v = value->Uint32Value();
+    const int v = value.toInt32();
     if (r && index < static_cast<quint32>(r->image.width() * r->image.height() * 4) && v >= 0 && v <= 255) {
         const quint32 w = r->image.width();
         const quint32 row = (index / 4) / w;
@@ -2856,7 +3063,6 @@ v8::Handle<v8::Value> ctx2d_pixelArray_indexed_set(uint32_t index, v8::Local<v8:
             break;
         }
     }
-    return v8::Undefined();
 }
 /*!
     \qmlmethod CanvasImageData QtQuick2::Context2D::createImageData(real sw, real sh)
@@ -2879,105 +3085,107 @@ v8::Handle<v8::Value> ctx2d_pixelArray_indexed_set(uint32_t index, v8::Local<v8:
     \sa Canvas::loadImage(), QtQuick2::Canvas::unloadImage(),
         QtQuick2::Canvas::isImageLoaded
   */
-static v8::Handle<v8::Value> ctx2d_createImageData(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_createImageData(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE();
+    QV8Engine *engine = ctx->engine->v8Engine;
 
-    if (args.Length() == 1) {
-        if (args[0]->IsObject()) {
-            v8::Local<v8::Object> imgData = args[0]->ToObject();
-            QV8Context2DPixelArrayResource *pa = v8_resource_cast<QV8Context2DPixelArrayResource>(imgData->GetInternalField(0)->ToObject());
+    if (ctx->argumentCount == 1) {
+        if (QQuickJSContext2DImageData *imgData = ctx->arguments[0].as<QQuickJSContext2DImageData>()) {
+            QQuickJSContext2DPixelData *pa = imgData->pixelData.as<QQuickJSContext2DPixelData>();
             if (pa) {
-                qreal w = imgData->Get(v8::String::New("width"))->NumberValue();
-                qreal h = imgData->Get(v8::String::New("height"))->NumberValue();
+                qreal w = pa->image.width();
+                qreal h = pa->image.height();
                 return qt_create_image_data(w, h, engine, QImage());
             }
-        } else if (args[0]->IsString()) {
-            QImage image = r->context->createPixmap(QUrl(engine->toString(args[0]->ToString())))->image();
+        } else if (ctx->arguments[0].isString()) {
+            QImage image = r->context->createPixmap(QUrl(ctx->arguments[0].toQString()))->image();
             return qt_create_image_data(image.width(), image.height(), engine, image);
         }
-    } else if (args.Length() == 2) {
-        qreal w = args[0]->NumberValue();
-        qreal h = args[1]->NumberValue();
+    } else if (ctx->argumentCount == 2) {
+        qreal w = ctx->arguments[0].toNumber();
+        qreal h = ctx->arguments[1].toNumber();
 
         if (!qIsFinite(w) || !qIsFinite(h))
-            V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createImageData(): invalid arguments");
+            V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createImageData(): invalid arguments");
 
         if (w > 0 && h > 0)
             return qt_create_image_data(w, h, engine, QImage());
         else
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createImageData(): invalid arguments");
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createImageData(): invalid arguments");
     }
-    return v8::Undefined();
+    return QV4::Value::undefinedValue();
 }
 
 /*!
   \qmlmethod CanvasImageData QtQuick2::Context2D::getImageData(real sx, real sy, real sw, real sh)
   Returns an CanvasImageData object containing the image data for the given rectangle of the canvas.
   */
-static v8::Handle<v8::Value> ctx2d_getImageData(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_getImageData(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
 
-    QV8Engine *engine = V8ENGINE();
-    if (args.Length() == 4) {
-        qreal x = args[0]->NumberValue();
-        qreal y = args[1]->NumberValue();
-        qreal w = args[2]->NumberValue();
-        qreal h = args[3]->NumberValue();
+    QV8Engine *engine = ctx->engine->v8Engine;
+    if (ctx->argumentCount == 4) {
+        qreal x = ctx->arguments[0].toNumber();
+        qreal y = ctx->arguments[1].toNumber();
+        qreal w = ctx->arguments[2].toNumber();
+        qreal h = ctx->arguments[3].toNumber();
         if (!qIsFinite(x) || !qIsFinite(y) || !qIsFinite(w) || !qIsFinite(w))
-            V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "getImageData(): Invalid arguments");
+            V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "getImageData(): Invalid arguments");
 
         if (w <= 0 || h <= 0)
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "getImageData(): Invalid arguments");
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "getImageData(): Invalid arguments");
 
         QImage image = r->context->canvas()->toImage(QRectF(x, y, w, h));
-        v8::Local<v8::Object> imageData = qt_create_image_data(w, h, engine, image);
+        QV4::Value imageData = qt_create_image_data(w, h, engine, image);
 
         return imageData;
     }
-    return v8::Null();
+    return QV4::Value::nullValue();
 }
 
 /*!
   \qmlmethod object QtQuick2::Context2D::putImageData(CanvasImageData imageData, real dx, real dy, real dirtyX, real dirtyY, real dirtyWidth, real dirtyHeight)
   Paints the data from the given ImageData object onto the canvas. If a dirty rectangle (\a dirtyX, \a dirtyY, \a dirtyWidth, \a dirtyHeight) is provided, only the pixels from that rectangle are painted.
   */
-static v8::Handle<v8::Value> ctx2d_putImageData(const v8::Arguments &args)
+QV4::Value QQuickJSContext2DPrototype::method_putImageData(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
+    QQuickJSContext2D *r = ctx->thisObject.as<QQuickJSContext2D>();
     CHECK_CONTEXT(r)
-    if (args.Length() != 3 && args.Length() != 7)
-        return v8::Undefined();
+    if (ctx->argumentCount != 3 && ctx->argumentCount != 7)
+        return QV4::Value::undefinedValue();
 
-    if (args[0]->IsNull() || !args[0]->IsObject()) {
-        V8THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "Context2D::putImageData, the image data type mismatch");
-    }
-    qreal dx = args[1]->NumberValue();
-    qreal dy = args[2]->NumberValue();
+    if (!ctx->arguments[0].isObject())
+        V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "Context2D::putImageData, the image data type mismatch");
+
+    qreal dx = ctx->arguments[1].toNumber();
+    qreal dy = ctx->arguments[2].toNumber();
     qreal w, h, dirtyX, dirtyY, dirtyWidth, dirtyHeight;
 
     if (!qIsFinite(dx) || !qIsFinite(dy))
-        V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
+        V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
 
-    v8::Local<v8::Object> imageData = args[0]->ToObject();
-    QV8Context2DPixelArrayResource *pixelArray = v8_resource_cast<QV8Context2DPixelArrayResource>(imageData->Get(v8::String::New("data"))->ToObject());
+    QQuickJSContext2DImageData *imageData = ctx->arguments[0].as<QQuickJSContext2DImageData>();
+    if (!imageData)
+        return ctx->thisObject;
+
+    QQuickJSContext2DPixelData *pixelArray = imageData->pixelData.as<QQuickJSContext2DPixelData>();
     if (pixelArray) {
-        w = imageData->Get(v8::String::New("width"))->NumberValue();
-        h = imageData->Get(v8::String::New("height"))->NumberValue();
+        w = pixelArray->image.width();
+        h = pixelArray->image.height();
 
-        if (args.Length() == 7) {
-            dirtyX = args[3]->NumberValue();
-            dirtyY = args[4]->NumberValue();
-            dirtyWidth = args[5]->NumberValue();
-            dirtyHeight = args[6]->NumberValue();
+        if (ctx->argumentCount == 7) {
+            dirtyX = ctx->arguments[3].toNumber();
+            dirtyY = ctx->arguments[4].toNumber();
+            dirtyWidth = ctx->arguments[5].toNumber();
+            dirtyHeight = ctx->arguments[6].toNumber();
 
             if (!qIsFinite(dirtyX) || !qIsFinite(dirtyY) || !qIsFinite(dirtyWidth) || !qIsFinite(dirtyHeight))
-                V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
+                V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
 
 
             if (dirtyWidth < 0) {
@@ -3009,7 +3217,7 @@ static v8::Handle<v8::Value> ctx2d_putImageData(const v8::Arguments &args)
             }
 
             if (dirtyWidth <=0 || dirtyHeight <= 0)
-                return args.This();
+                return ctx->thisObject;
         } else {
             dirtyX = 0;
             dirtyY = 0;
@@ -3020,7 +3228,7 @@ static v8::Handle<v8::Value> ctx2d_putImageData(const v8::Arguments &args)
         QImage image = pixelArray->image.copy(dirtyX, dirtyY, dirtyWidth, dirtyHeight);
         r->context->buffer()->drawImage(image, QRectF(dirtyX, dirtyY, dirtyWidth, dirtyHeight), QRectF(dx, dy, dirtyWidth, dirtyHeight));
     }
-    return args.This();
+    return ctx->thisObject;
 }
 
 /*!
@@ -3043,40 +3251,40 @@ static v8::Handle<v8::Value> ctx2d_putImageData(const v8::Arguments &args)
   gradient.addColorStop(0.7, 'rgba(0, 255, 255, 1');
   \endcode
   */
-static v8::Handle<v8::Value> ctx2d_gradient_addColorStop(const v8::Arguments &args)
+QV4::Value QQuickContext2DStyle::gradient_proto_addColorStop(QV4::SimpleCallContext *ctx)
 {
-    QV8Context2DStyleResource *style = v8_resource_cast<QV8Context2DStyleResource>(args.This());
+    QQuickContext2DStyle *style = ctx->thisObject.as<QQuickContext2DStyle>();
     if (!style)
-        V8THROW_ERROR("Not a CanvasGradient object");
+        V4THROW_ERROR("Not a CanvasGradient object");
 
-    QV8Engine *engine = V8ENGINE();
+    QV8Engine *engine = ctx->engine->v8Engine;
 
-    if (args.Length() == 2) {
+    if (ctx->argumentCount == 2) {
 
         if (!style->brush.gradient())
-            V8THROW_ERROR("Not a valid CanvasGradient object, can't get the gradient information");
+            V4THROW_ERROR("Not a valid CanvasGradient object, can't get the gradient information");
         QGradient gradient = *(style->brush.gradient());
-        qreal pos = args[0]->NumberValue();
+        qreal pos = ctx->arguments[0].toNumber();
         QColor color;
 
-        if (args[1]->IsObject()) {
-            color = engine->toVariant(args[1], qMetaTypeId<QColor>()).value<QColor>();
+        if (ctx->arguments[1].asObject()) {
+            color = engine->toVariant(ctx->arguments[1], qMetaTypeId<QColor>()).value<QColor>();
         } else {
-            color = qt_color_from_string(args[1]);
+            color = qt_color_from_string(ctx->arguments[1]);
         }
         if (pos < 0.0 || pos > 1.0 || !qIsFinite(pos)) {
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "CanvasGradient: parameter offset out of range");
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "CanvasGradient: parameter offset out of range");
         }
 
         if (color.isValid()) {
             gradient.setColorAt(pos, color);
         } else {
-            V8THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "CanvasGradient: parameter color is not a valid color string");
+            V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "CanvasGradient: parameter color is not a valid color string");
         }
         style->brush = gradient;
     }
 
-    return args.This();
+    return ctx->thisObject;
 }
 
 void QQuickContext2D::scale(qreal x,  qreal y)
@@ -3688,14 +3896,14 @@ QQuickContext2D::~QQuickContext2D()
     m_texture->deleteLater();
 }
 
-v8::Handle<v8::Object> QQuickContext2D::v8value() const
+QV4::Value QQuickContext2D::v4value() const
 {
-    return m_v8value;
+    return m_v4value.value();
 }
 
 QStringList QQuickContext2D::contextNames() const
 {
-    return QStringList() << QLatin1String("2d");
+    return QStringList() << QStringLiteral("2d");
 }
 
 void QQuickContext2D::init(QQuickCanvasItem *canvasItem, const QVariantMap &args)
@@ -3802,105 +4010,39 @@ QImage QQuickContext2D::toImage(const QRectF& bounds)
 
 QQuickContext2DEngineData::QQuickContext2DEngineData(QV8Engine *engine)
 {
-    v8::HandleScope handle_scope;
-    v8::Context::Scope scope(engine->context());
-
-    v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
-    ft->InstanceTemplate()->SetHasExternalResource(true);
-    ft->PrototypeTemplate()->SetAccessor(v8::String::New("canvas"), ctx2d_canvas, 0, v8::External::New(engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("restore"), V8FUNCTION(ctx2d_restore, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("reset"), V8FUNCTION(ctx2d_reset, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("save"), V8FUNCTION(ctx2d_save, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("rotate"), V8FUNCTION(ctx2d_rotate, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("scale"), V8FUNCTION(ctx2d_scale, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("resetTransform"), V8FUNCTION(ctx2d_resetTransform, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("setTransform"), V8FUNCTION(ctx2d_setTransform, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("transform"), V8FUNCTION(ctx2d_transform, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("translate"), V8FUNCTION(ctx2d_translate, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("shear"), V8FUNCTION(ctx2d_shear, engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("globalAlpha"), ctx2d_globalAlpha, ctx2d_globalAlpha_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("globalCompositeOperation"), ctx2d_globalCompositeOperation, ctx2d_globalCompositeOperation_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("fillRule"), ctx2d_fillRule, ctx2d_fillRule_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("fillStyle"), ctx2d_fillStyle, ctx2d_fillStyle_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("strokeStyle"), ctx2d_strokeStyle, ctx2d_strokeStyle_set, v8::External::New(engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("createLinearGradient"), V8FUNCTION(ctx2d_createLinearGradient, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("createRadialGradient"), V8FUNCTION(ctx2d_createRadialGradient, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("createConicalGradient"), V8FUNCTION(ctx2d_createConicalGradient, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("createPattern"), V8FUNCTION(ctx2d_createPattern, engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("lineCap"), ctx2d_lineCap, ctx2d_lineCap_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("lineJoin"), ctx2d_lineJoin, ctx2d_lineJoin_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("lineWidth"), ctx2d_lineWidth, ctx2d_lineWidth_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("miterLimit"), ctx2d_miterLimit, ctx2d_miterLimit_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("shadowBlur"), ctx2d_shadowBlur, ctx2d_shadowBlur_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("shadowColor"), ctx2d_shadowColor, ctx2d_shadowColor_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("shadowOffsetX"), ctx2d_shadowOffsetX, ctx2d_shadowOffsetX_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("shadowOffsetY"), ctx2d_shadowOffsetY, ctx2d_shadowOffsetY_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("path"), ctx2d_path, ctx2d_path_set, v8::External::New(engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("clearRect"), V8FUNCTION(ctx2d_clearRect, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("fillRect"), V8FUNCTION(ctx2d_fillRect, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("strokeRect"), V8FUNCTION(ctx2d_strokeRect, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("arc"), V8FUNCTION(ctx2d_arc, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("arcTo"), V8FUNCTION(ctx2d_arcTo, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("beginPath"), V8FUNCTION(ctx2d_beginPath, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("bezierCurveTo"), V8FUNCTION(ctx2d_bezierCurveTo, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("clip"), V8FUNCTION(ctx2d_clip, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("closePath"), V8FUNCTION(ctx2d_closePath, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("fill"), V8FUNCTION(ctx2d_fill, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("lineTo"), V8FUNCTION(ctx2d_lineTo, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("moveTo"), V8FUNCTION(ctx2d_moveTo, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("quadraticCurveTo"), V8FUNCTION(ctx2d_quadraticCurveTo, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("rect"), V8FUNCTION(ctx2d_rect, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("roundedRect"), V8FUNCTION(ctx2d_roundedRect, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("text"), V8FUNCTION(ctx2d_text, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("ellipse"), V8FUNCTION(ctx2d_ellipse, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("stroke"), V8FUNCTION(ctx2d_stroke, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("isPointInPath"), V8FUNCTION(ctx2d_isPointInPath, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("drawFocusRing"), V8FUNCTION(ctx2d_drawFocusRing, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("caretBlinkRate"), V8FUNCTION(ctx2d_caretBlinkRate, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("setCaretSelectionRect"), V8FUNCTION(ctx2d_setCaretSelectionRect, engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("font"), ctx2d_font, ctx2d_font_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("textAlign"), ctx2d_textAlign, ctx2d_textAlign_set, v8::External::New(engine));
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("textBaseline"), ctx2d_textBaseline, ctx2d_textBaseline_set, v8::External::New(engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("fillText"), V8FUNCTION(ctx2d_fillText, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("measureText"), V8FUNCTION(ctx2d_measureText, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("strokeText"), V8FUNCTION(ctx2d_strokeText, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("drawImage"), V8FUNCTION(ctx2d_drawImage, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("createImageData"), V8FUNCTION(ctx2d_createImageData, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("getImageData"), V8FUNCTION(ctx2d_getImageData, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("putImageData"), V8FUNCTION(ctx2d_putImageData, engine));
-
-    constructorContext = qPersistentNew(ft->GetFunction());
-
-    v8::Local<v8::FunctionTemplate> ftGradient = v8::FunctionTemplate::New();
-    ftGradient->InstanceTemplate()->SetHasExternalResource(true);
-    ftGradient->PrototypeTemplate()->Set(v8::String::New("addColorStop"), V8FUNCTION(ctx2d_gradient_addColorStop, engine));
-    constructorGradient = qPersistentNew(ftGradient->GetFunction());
-
-    v8::Local<v8::FunctionTemplate> ftPattern = v8::FunctionTemplate::New();
-    ftPattern->InstanceTemplate()->SetHasExternalResource(true);
-    constructorPattern = qPersistentNew(ftPattern->GetFunction());
-
-    v8::Local<v8::FunctionTemplate> ftPixelArray = v8::FunctionTemplate::New();
-    ftPixelArray->InstanceTemplate()->SetHasExternalResource(true);
-    ftPixelArray->InstanceTemplate()->SetAccessor(v8::String::New("length"), ctx2d_pixelArray_length, 0, v8::External::New(engine));
-    ftPixelArray->InstanceTemplate()->SetIndexedPropertyHandler(ctx2d_pixelArray_indexed, ctx2d_pixelArray_indexed_set, 0, 0, 0, v8::External::New(engine));
-    constructorPixelArray = qPersistentNew(ftPixelArray->GetFunction());
-
-    v8::Local<v8::FunctionTemplate> ftImageData = v8::FunctionTemplate::New();
-    ftImageData->InstanceTemplate()->SetAccessor(v8::String::New("width"), ctx2d_imageData_width, 0, v8::External::New(engine));
-    ftImageData->InstanceTemplate()->SetAccessor(v8::String::New("height"), ctx2d_imageData_height, 0, v8::External::New(engine));
-    ftImageData->InstanceTemplate()->SetAccessor(v8::String::New("data"), ctx2d_imageData_data, 0, v8::External::New(engine));
-    ftImageData->InstanceTemplate()->SetInternalFieldCount(1);
-    constructorImageData = qPersistentNew(ftImageData->GetFunction());
+    QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
+
+    QV4::Object *proto = new (v4->memoryManager) QQuickJSContext2DPrototype(v4);
+    proto->defineAccessorProperty(v4, QStringLiteral("strokeStyle"), QQuickJSContext2D::method_get_strokeStyle, QQuickJSContext2D::method_set_strokeStyle);
+    proto->defineAccessorProperty(v4, QStringLiteral("font"), QQuickJSContext2D::method_get_font, QQuickJSContext2D::method_set_font);
+    proto->defineAccessorProperty(v4, QStringLiteral("fillRule"), QQuickJSContext2D::method_get_fillRule, QQuickJSContext2D::method_set_fillRule);
+    proto->defineAccessorProperty(v4, QStringLiteral("globalAlpha"), QQuickJSContext2D::method_get_globalAlpha, QQuickJSContext2D::method_set_globalAlpha);
+    proto->defineAccessorProperty(v4, QStringLiteral("lineCap"), QQuickJSContext2D::method_get_lineCap, QQuickJSContext2D::method_set_lineCap);
+    proto->defineAccessorProperty(v4, QStringLiteral("shadowOffsetX"), QQuickJSContext2D::method_get_shadowOffsetX, QQuickJSContext2D::method_set_shadowOffsetX);
+    proto->defineAccessorProperty(v4, QStringLiteral("shadowOffsetY"), QQuickJSContext2D::method_get_shadowOffsetY, QQuickJSContext2D::method_set_shadowOffsetY);
+    proto->defineAccessorProperty(v4, QStringLiteral("globalCompositeOperation"), QQuickJSContext2D::method_get_globalCompositeOperation, QQuickJSContext2D::method_set_globalCompositeOperation);
+    proto->defineAccessorProperty(v4, QStringLiteral("miterLimit"), QQuickJSContext2D::method_get_miterLimit, QQuickJSContext2D::method_set_miterLimit);
+    proto->defineAccessorProperty(v4, QStringLiteral("fillStyle"), QQuickJSContext2D::method_get_fillStyle, QQuickJSContext2D::method_set_fillStyle);
+    proto->defineAccessorProperty(v4, QStringLiteral("shadowColor"), QQuickJSContext2D::method_get_shadowColor, QQuickJSContext2D::method_set_shadowColor);
+    proto->defineAccessorProperty(v4, QStringLiteral("textBaseline"), QQuickJSContext2D::method_get_textBaseline, QQuickJSContext2D::method_set_textBaseline);
+    proto->defineAccessorProperty(v4, QStringLiteral("path"), QQuickJSContext2D::method_get_path, QQuickJSContext2D::method_set_path);
+    proto->defineAccessorProperty(v4, QStringLiteral("lineJoin"), QQuickJSContext2D::method_get_lineJoin, QQuickJSContext2D::method_set_lineJoin);
+    proto->defineAccessorProperty(v4, QStringLiteral("lineWidth"), QQuickJSContext2D::method_get_lineWidth, QQuickJSContext2D::method_set_lineWidth);
+    proto->defineAccessorProperty(v4, QStringLiteral("textAlign"), QQuickJSContext2D::method_get_textAlign, QQuickJSContext2D::method_set_textAlign);
+    proto->defineAccessorProperty(v4, QStringLiteral("shadowBlur"), QQuickJSContext2D::method_get_shadowBlur, QQuickJSContext2D::method_set_shadowBlur);
+    contextPrototype = QV4::Value::fromObject(proto);
+
+    proto = v4->newObject();
+    proto->defineDefaultProperty(v4, QStringLiteral("addColorStop"), QQuickContext2DStyle::gradient_proto_addColorStop, 0);
+    gradientProto = QV4::Value::fromObject(proto);
+
+    proto = v4->newObject();
+    proto->defineAccessorProperty(v4->id_length, QQuickJSContext2DPixelData::proto_get_length, 0);
+    pixelArrayProto = QV4::Value::fromObject(proto);
 }
 
 QQuickContext2DEngineData::~QQuickContext2DEngineData()
 {
-    qPersistentDispose(constructorContext);
-    qPersistentDispose(constructorGradient);
-    qPersistentDispose(constructorPattern);
-    qPersistentDispose(constructorImageData);
-    qPersistentDispose(constructorPixelArray);
 }
 
 void QQuickContext2D::popState()
@@ -3983,22 +4125,18 @@ void QQuickContext2D::reset()
 
 void QQuickContext2D::setV8Engine(QV8Engine *engine)
 {
-    v8::HandleScope handle_scope;
-    v8::Context::Scope scope(engine->context());
-
     if (m_v8engine != engine) {
         m_v8engine = engine;
 
-        qPersistentDispose(m_v8value);
-
         if (m_v8engine == 0)
             return;
 
         QQuickContext2DEngineData *ed = engineData(engine);
-        m_v8value = qPersistentNew(ed->constructorContext->NewInstance());
-        QV8Context2DResource *r = new QV8Context2DResource(engine);
-        r->context = this;
-        m_v8value->SetExternalResource(r);
+        QV4::ExecutionEngine *v4Engine = QV8Engine::getV4(engine);
+        QQuickJSContext2D *wrapper = new (v4Engine->memoryManager) QQuickJSContext2D(v4Engine);
+        wrapper->prototype = ed->contextPrototype.value().asObject();
+        wrapper->context = this;
+        m_v4value = QV4::Value::fromObject(wrapper);
     }
 }
 
diff --git a/src/quick/items/context2d/qquickcontext2d_p.h b/src/quick/items/context2d/qquickcontext2d_p.h
index 6256249327..8164108bd3 100644
--- a/src/quick/items/context2d/qquickcontext2d_p.h
+++ b/src/quick/items/context2d/qquickcontext2d_p.h
@@ -55,6 +55,7 @@
 #include <private/qv8engine_p.h>
 #include <QtCore/QWaitCondition>
 
+#include <private/qv4value_p.h>
 
 //#define QQUICKCONTEXT2D_DEBUG //enable this for just DEBUG purpose!
 
@@ -174,7 +175,7 @@ public:
     QSGDynamicTexture *texture() const;
     QImage toImage(const QRectF& bounds);
 
-    v8::Handle<v8::Object> v8value() const;
+    QV4::Value v4value() const;
     void setV8Engine(QV8Engine *eng);
 
     QQuickCanvasItem* canvas() const { return m_canvas; }
@@ -234,13 +235,13 @@ public:
     QQuickCanvasItem* m_canvas;
     QQuickContext2DCommandBuffer* m_buffer;
     QPainterPath m_path;
-    v8::Local<v8::Value> m_fillStyle;
-    v8::Local<v8::Value> m_strokeStyle;
-    v8::Handle<v8::Value> m_v8path;
+    QV4::PersistentValue m_fillStyle;
+    QV4::PersistentValue m_strokeStyle;
+    QV4::PersistentValue m_v4path;
     QV8Engine *m_v8engine;
     QSurface *m_surface;
     QOpenGLContext *m_glContext;
-    v8::Persistent<v8::Object> m_v8value;
+    QV4::PersistentValue m_v4value;
     QQuickContext2DTexture *m_texture;
     QQuickCanvasItem::RenderTarget m_renderTarget;
     QQuickCanvasItem::RenderStrategy m_renderStrategy;