qquickcontext2d.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qquickcontext2d_p.h"
#include "qquickcontext2dcommandbuffer_p.h"
#include "qquickcanvasitem_p.h"
#include <private/qtquickglobal_p.h>
#include <private/qquickcontext2dtexture_p.h>
#include <private/qquickitem_p.h>
#if QT_CONFIG(quick_shadereffect)
#include <QtQuick/private/qquickshadereffectsource_p.h>
#endif
#include <qsgrendererinterface.h>
 
#include <QtQuick/private/qsgcontext_p.h>
#include <private/qquicksvgparser_p.h>
#if QT_CONFIG(quick_path)
#include <private/qquickpath_p.h>
#endif
#include <private/qquickimage_p_p.h>
 
#include <qqmlinfo.h>
 
#include <qqmlengine.h>
#include <private/qv4domerrors_p.h>
#include <private/qv4engine_p.h>
#include <private/qv4object_p.h>
#include <private/qv4qobjectwrapper_p.h>
#include <private/qquickwindow_p.h>
 
#include <private/qv4value_p.h>
#include <private/qv4functionobject_p.h>
#include <private/qv4objectproto_p.h>
#include <private/qv4scopedvalue_p.h>
#include <private/qlocale_tools_p.h>
 
#include <QtCore/qmath.h>
#include <QtCore/qvector.h>
#include <QtCore/private/qnumeric_p.h>
#include <QtCore/QRunnable>
#include <QtGui/qguiapplication.h>
#include <private/qguiapplication_p.h>
#include <qpa/qplatformintegration.h>
 
#include <private/qsgdefaultrendercontext_p.h>
 
#include <QtCore/qpointer.h>
 
#include <cmath>
#if defined(Q_OS_QNX) || defined(Q_OS_ANDROID)
#include <ctype.h>
#endif
 
QT_BEGIN_NAMESPACE
#define CHECK_CONTEXT(r)     if (!r || !r->d()->context() || !r->d()->context()->bufferValid()) \
                                THROW_GENERIC_ERROR("Not a Context2D object");
 
#define CHECK_CONTEXT_SETTER(r)     if (!r || !r->d()->context() || !r->d()->context()->bufferValid()) \
                                       THROW_GENERIC_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))
Q_QUICK_EXPORT QColor qt_color_from_string(const QV4::Value &name)
{
    QByteArray str = name.toQString().toUtf8();
 
    char *p = str.data();
    int len = str.size();
    //rgb/hsl color string has at least 7 characters
    if (!p || len > 255 || len <= 7)
        return QColor::fromString(p);
    else {
        bool isRgb(false), isHsl(false), hasAlpha(false);
        Q_UNUSED(isHsl);
 
        while (isspace(*p)) p++;
        if (strncmp(p, "rgb", 3) == 0)
            isRgb = true;
        else if (strncmp(p, "hsl", 3) == 0)
            isHsl = true;
        else
            return QColor::fromString(p);
 
        p+=3; //skip "rgb" or "hsl"
        hasAlpha = (*p == 'a') ? true : false;
 
        ++p; //skip "("
 
        if (hasAlpha) ++p; //skip "a"
 
        int rh, gs, bl, alpha = 255;
 
        //red
        while (isspace(*p)) p++;
        rh = strtol(p, &p, 10);
        if (*p == '%') {
            rh = qRound(rh/100.0 * 255);
            ++p;
        }
        if (*p++ != ',') return QColor();
 
        //green
        while (isspace(*p)) p++;
        gs = strtol(p, &p, 10);
        if (*p == '%') {
            gs = qRound(gs/100.0 * 255);
            ++p;
        }
        if (*p++ != ',') return QColor();
 
        //blue
        while (isspace(*p)) p++;
        bl = strtol(p, &p, 10);
        if (*p == '%') {
            bl = qRound(bl/100.0 * 255);
            ++p;
        }
 
        if (hasAlpha) {
            if (*p++!= ',') return QColor();
            while (isspace(*p)) p++;
            bool ok = false;
            alpha = qRound(qstrtod(p, const_cast<const char **>(&p), &ok) * 255);
        }
 
        if (*p != ')') return QColor();
        if (isRgb)
            return QColor::fromRgba(qRgba(qClamp(rh, 0, 255), qClamp(gs, 0, 255), qClamp(bl, 0, 255), qClamp(alpha, 0, 255)));
        else if (isHsl)
            return QColor::fromHsl(qClamp(rh, 0, 359), qClamp(gs, 0, 255), qClamp(bl, 0, 255), qClamp(alpha, 0, 255));
    }
    return QColor();
}
 
static int qParseFontSizeFromToken(QStringView fontSizeToken, bool &ok)
{
    ok = false;
    float size = fontSizeToken.trimmed().toFloat(&ok);
    if (ok) {
        return int(size);
    }
    qWarning().nospace() << "Context2D: A font size of " << fontSizeToken << " is invalid.";
    return 0;
}
 
/*
    Attempts to set the font size of \a font to \a fontSizeToken, returning
    \c true if successful. If the font size is invalid, \c false is returned
    and a warning is printed.
*/
static bool qSetFontSizeFromToken(QFont &font, QStringView fontSizeToken)
{
    const QStringView trimmedToken = fontSizeToken.trimmed();
    const QStringView unitStr = trimmedToken.right(2);
    const QStringView value = trimmedToken.left(trimmedToken.size() - 2);
    bool ok = false;
    int size = 0;
    if (unitStr == QLatin1String("px")) {
        size = qParseFontSizeFromToken(value, ok);
        if (ok) {
            font.setPixelSize(size);
            return true;
        }
    } else if (unitStr == QLatin1String("pt")) {
        size = qParseFontSizeFromToken(value, ok);
        if (ok) {
            font.setPointSize(size);
            return true;
        }
    } else {
        qWarning().nospace() << "Context2D: Invalid font size unit in font string.";
    }
    return false;
}
 
/*
    Returns a list of all of the families in \a fontFamiliesString, where
    each family is separated by spaces. Families with spaces in their name
    must be quoted.
*/
static QStringList qExtractFontFamiliesFromString(QStringView fontFamiliesString)
{
    QStringList extractedFamilies;
    int quoteIndex = -1;
    QString currentFamily;
    for (int index = 0; index < fontFamiliesString.size(); ++index) {
        const QChar ch = fontFamiliesString.at(index);
        if (ch == u'"' || ch == u'\'') {
            if (quoteIndex == -1) {
                quoteIndex = index;
            } else {
                if (ch == fontFamiliesString.at(quoteIndex)) {
                    // Found the matching quote. +1/-1 because we don't want the quote as part of the name.
                    const QString family = fontFamiliesString.mid(quoteIndex + 1, index - quoteIndex - 1).toString();
                    extractedFamilies.push_back(family);
                    currentFamily.clear();
                    quoteIndex = -1;
                } else {
                    qWarning().nospace() << "Context2D: Mismatched quote in font string.";
                    return QStringList();
                }
            }
        } else if (ch == u' ' && quoteIndex == -1) {
            // This is a space that's not within quotes...
            if (!currentFamily.isEmpty()) {
                // and there is a current family; consider it the end of the current family.
                extractedFamilies.push_back(currentFamily);
                currentFamily.clear();
            } // else: ignore the space
        } else {
            currentFamily.push_back(ch);
        }
    }
    if (!currentFamily.isEmpty()) {
        if (quoteIndex == -1) {
            // This is the end of the string, so add this family to our list.
            extractedFamilies.push_back(currentFamily);
        } else {
            qWarning().nospace() << "Context2D: Unclosed quote in font string.";
            return QStringList();
        }
    }
    if (extractedFamilies.isEmpty()) {
        qWarning().nospace() << "Context2D: Missing or misplaced font family in font string"
            << " (it must come after the font size).";
    }
    return extractedFamilies;
}
 
/*
    Tries to set a family on \a font using the families provided in \a fontFamilyTokens.
 
    The list is ordered by preference, with the first family having the highest preference.
    If the first family is invalid, the next family in the list is evaluated.
    This process is repeated until a valid font is found (at which point the function
    will return \c true and the family set on \a font) or there are no more
    families left, at which point a warning is printed and \c false is returned.
*/
static bool qSetFontFamilyFromTokens(QFont &font, const QStringList &fontFamilyTokens)
{
    for (const QString &fontFamilyToken : fontFamilyTokens) {
        if (QFontDatabase::hasFamily(fontFamilyToken)) {
            font.setFamily(fontFamilyToken);
            return true;
        } else {
            // Can't find a family matching this name; if it's a generic family,
            // try searching for the default family for it by using style hints.
            int styleHint = -1;
            if (fontFamilyToken.compare(QLatin1String("serif")) == 0) {
                styleHint = QFont::Serif;
            } else if (fontFamilyToken.compare(QLatin1String("sans-serif")) == 0) {
                styleHint = QFont::SansSerif;
            } else if (fontFamilyToken.compare(QLatin1String("cursive")) == 0) {
                styleHint = QFont::Cursive;
            } else if (fontFamilyToken.compare(QLatin1String("monospace")) == 0) {
                styleHint = QFont::Monospace;
            } else if (fontFamilyToken.compare(QLatin1String("fantasy")) == 0) {
                styleHint = QFont::Fantasy;
            }
            if (styleHint != -1) {
                QFont tmp;
                tmp.setStyleHint(static_cast<QFont::StyleHint>(styleHint));
                font.setFamily(tmp.defaultFamily());
                return true;
            }
        }
    }
    qWarning("Context2D: The font families specified are invalid: %s", qPrintable(fontFamilyTokens.join(QString()).trimmed()));
    return false;
}
 
enum FontToken
{
    NoTokens = 0x00,
    FontStyle = 0x01,
    FontVariant = 0x02,
    FontWeight = 0x04
};
 
#define Q_TRY_SET_TOKEN(token, value, setStatement) \
if (!(usedTokens & token)) { \
    usedTokens |= token; \
    setStatement; \
} else { \
    qWarning().nospace() << "Context2D: Duplicate token " << QLatin1String(value) << " found in font string."; \
    return currentFont; \
}
 
/*
    Parses a font string based on the CSS shorthand font property.
 
    See: http://www.w3.org/TR/css3-fonts/#font-prop
*/
static QFont qt_font_from_string(const QString& fontString, const QFont &currentFont) {
    if (fontString.isEmpty()) {
        qWarning().nospace() << "Context2D: Font string is empty.";
        return currentFont;
    }
 
    // We know that font-size must be specified and it must be before font-family
    // (which could potentially have "px" or "pt" in its name), so extract it now.
    int fontSizeEnd = fontString.indexOf(QLatin1String("px"));
    if (fontSizeEnd == -1)
        fontSizeEnd = fontString.indexOf(QLatin1String("pt"));
    if (fontSizeEnd == -1) {
        qWarning().nospace() << "Context2D: Invalid font size unit in font string.";
        return currentFont;
    }
 
    int fontSizeStart = fontString.lastIndexOf(u' ', fontSizeEnd);
    if (fontSizeStart == -1) {
        // The font size might be the first token in the font string, which is OK.
        // Regardless, we'll find out if the font is invalid with qSetFontSizeFromToken().
        fontSizeStart = 0;
    } else {
        // Don't want to take the leading space.
        ++fontSizeStart;
    }
 
    // + 2 for the unit, +1 for the space that we require.
    fontSizeEnd += 3;
 
    QFont newFont;
    if (!qSetFontSizeFromToken(newFont, QStringView{fontString}.mid(fontSizeStart, fontSizeEnd - fontSizeStart)))
        return currentFont;
 
    // We don't want to parse the size twice, so remove it now.
    QString remainingFontString = fontString;
    remainingFontString.remove(fontSizeStart, fontSizeEnd - fontSizeStart);
    QStringView remainingFontStringRef(remainingFontString);
 
    // Next, we have to take any font families out, as QString::split() will ruin quoted family names.
    const QStringView fontFamiliesString = remainingFontStringRef.mid(fontSizeStart);
    remainingFontStringRef.truncate(fontSizeStart);
    QStringList fontFamilies = qExtractFontFamiliesFromString(fontFamiliesString);
    if (fontFamilies.isEmpty()) {
        return currentFont;
    }
    if (!qSetFontFamilyFromTokens(newFont, fontFamilies))
        return currentFont;
 
    // Now that we've removed the messy parts, we can split the font string on spaces.
    const QStringView trimmedTokensStr = remainingFontStringRef.trimmed();
    if (trimmedTokensStr.isEmpty()) {
        // No optional properties.
        return newFont;
    }
    const auto tokens = trimmedTokensStr.split(QLatin1Char(' '));
 
    int usedTokens = NoTokens;
    // Optional properties can be in any order, but font-size and font-family must be last.
    for (const QStringView &token : tokens) {
        if (token.compare(QLatin1String("normal")) == 0) {
            if (!(usedTokens & FontStyle) || !(usedTokens & FontVariant) || !(usedTokens & FontWeight)) {
                // Could be font-style, font-variant or font-weight.
                if (!(usedTokens & FontStyle)) {
                    // QFont::StyleNormal is the default for QFont::style.
                    usedTokens = usedTokens | FontStyle;
                } else if (!(usedTokens & FontVariant)) {
                    // QFont::MixedCase is the default for QFont::capitalization.
                    usedTokens |= FontVariant;
                } else if (!(usedTokens & FontWeight)) {
                    // QFont::Normal is the default for QFont::weight.
                    usedTokens |= FontWeight;
                }
            } else {
                qWarning().nospace() << "Context2D: Duplicate token \"normal\" found in font string.";
                return currentFont;
            }
        } else if (token.compare(QLatin1String("bold")) == 0) {
            Q_TRY_SET_TOKEN(FontWeight, "bold", newFont.setBold(true))
        } else if (token.compare(QLatin1String("italic")) == 0) {
            Q_TRY_SET_TOKEN(FontStyle, "italic", newFont.setStyle(QFont::StyleItalic))
        } else if (token.compare(QLatin1String("oblique")) == 0) {
            Q_TRY_SET_TOKEN(FontStyle, "oblique", newFont.setStyle(QFont::StyleOblique))
        } else if (token.compare(QLatin1String("small-caps")) == 0) {
            Q_TRY_SET_TOKEN(FontVariant, "small-caps", newFont.setCapitalization(QFont::SmallCaps))
        } else {
            bool conversionOk = false;
            int weight = token.toInt(&conversionOk);
            if (conversionOk) {
                Q_TRY_SET_TOKEN(FontWeight, "<font-weight>",
                                newFont.setWeight(QFont::Weight(weight)))
            } else {
                // The token is invalid or in the wrong place/order in the font string.
                qWarning().nospace() << "Context2D: Invalid or misplaced token " << token
                                     << " found in font string.";
                return currentFont;
            }
        }
    }
    return newFont;
}
 
class QQuickContext2DEngineData : public QV4::ExecutionEngine::Deletable
{
public:
    QQuickContext2DEngineData(QV4::ExecutionEngine *engine);
    ~QQuickContext2DEngineData();
 
    QV4::PersistentValue contextPrototype;
    QV4::PersistentValue gradientProto;
    QV4::PersistentValue pixelArrayProto;
};
 
V4_DEFINE_EXTENSION(QQuickContext2DEngineData, engineData)
 
namespace QV4 {
namespace Heap {
 
struct QQuickJSContext2D : Object {
    void init()
    {
        Object::init();
        m_context = nullptr;
    }
 
    void destroy()
    {
        delete m_context;
        Object::destroy();
    }
 
    QQuickContext2D *context() { return m_context ? *m_context : nullptr; }
    void setContext(QQuickContext2D *context)
    {
        if (m_context)
            *m_context = context;
        else
            m_context = new QPointer<QQuickContext2D>(context);
    }
 
private:
    QPointer<QQuickContext2D>* m_context;
};
 
struct QQuickJSContext2DPrototype : Object {
    void init() { Object::init(); }
};
 
struct QQuickContext2DStyle : Object {
    void init()
    {
        brush = new QBrush;
        patternRepeatX = false;
        patternRepeatY = false;
    }
    void destroy() {
        delete brush;
        Object::destroy();
    }
 
    QBrush *brush;
    bool patternRepeatX:1;
    bool patternRepeatY:1;
};
 
struct QQuickJSContext2DPixelData : Object {
    void init();
    void destroy() {
        delete image;
        Object::destroy();
    }
 
    QImage *image;
};
 
struct QQuickJSContext2DImageData : Object {
    void init();
 
    static void markObjects(QV4::Heap::Base *that, QV4::MarkStack *markStack) {
        static_cast<QQuickJSContext2DImageData *>(that)->pixelData.mark(markStack);
        Object::markObjects(that, markStack);
    }
 
    QV4::Value pixelData;
};
 
}
}
 
struct QQuickJSContext2D : public QV4::Object
{
    V4_OBJECT2(QQuickJSContext2D, QV4::Object)
    V4_NEEDS_DESTROY
 
    static QV4::ReturnedValue method_get_globalAlpha(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_globalAlpha(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_globalCompositeOperation(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_globalCompositeOperation(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_fillStyle(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_fillStyle(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_fillRule(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_fillRule(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_strokeStyle(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_strokeStyle(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
 
    static QV4::ReturnedValue method_get_lineCap(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_lineCap(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_lineJoin(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_lineJoin(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_lineWidth(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_lineWidth(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_miterLimit(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_miterLimit(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_lineDashOffset(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_lineDashOffset(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
 
    static QV4::ReturnedValue method_get_shadowBlur(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_shadowBlur(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_shadowColor(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_shadowColor(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_shadowOffsetX(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_shadowOffsetX(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_shadowOffsetY(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_shadowOffsetY(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
 
    // should these two be on the proto?
#if QT_CONFIG(quick_path)
    static QV4::ReturnedValue method_get_path(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_path(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
#endif
    static QV4::ReturnedValue method_get_font(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_font(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_textAlign(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_textAlign(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_textBaseline(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_set_textBaseline(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
};
 
DEFINE_OBJECT_VTABLE(QQuickJSContext2D);
 
 
struct QQuickJSContext2DPrototype : public QV4::Object
{
    V4_OBJECT2(QQuickJSContext2DPrototype, QV4::Object)
public:
    static QV4::Heap::QQuickJSContext2DPrototype *create(QV4::ExecutionEngine *engine)
    {
        QV4::Scope scope(engine);
        QV4::Scoped<QQuickJSContext2DPrototype> o(scope, engine->memoryManager->allocate<QQuickJSContext2DPrototype>());
 
        o->defineDefaultProperty(QStringLiteral("quadraticCurveTo"), method_quadraticCurveTo, 0);
        o->defineDefaultProperty(QStringLiteral("restore"), method_restore, 0);
        o->defineDefaultProperty(QStringLiteral("moveTo"), method_moveTo, 0);
        o->defineDefaultProperty(QStringLiteral("lineTo"), method_lineTo, 0);
        o->defineDefaultProperty(QStringLiteral("caretBlinkRate"), method_caretBlinkRate, 0);
        o->defineDefaultProperty(QStringLiteral("clip"), method_clip, 0);
        o->defineDefaultProperty(QStringLiteral("setTransform"), method_setTransform, 0);
        o->defineDefaultProperty(QStringLiteral("text"), method_text, 0);
        o->defineDefaultProperty(QStringLiteral("roundedRect"), method_roundedRect, 0);
        o->defineDefaultProperty(QStringLiteral("createPattern"), method_createPattern, 0);
        o->defineDefaultProperty(QStringLiteral("stroke"), method_stroke, 0);
        o->defineDefaultProperty(QStringLiteral("arc"), method_arc, 0);
        o->defineDefaultProperty(QStringLiteral("createImageData"), method_createImageData, 0);
        o->defineDefaultProperty(QStringLiteral("measureText"), method_measureText, 0);
        o->defineDefaultProperty(QStringLiteral("ellipse"), method_ellipse, 0);
        o->defineDefaultProperty(QStringLiteral("fill"), method_fill, 0);
        o->defineDefaultProperty(QStringLiteral("save"), method_save, 0);
        o->defineDefaultProperty(QStringLiteral("scale"), method_scale, 0);
        o->defineDefaultProperty(QStringLiteral("drawImage"), method_drawImage, 0);
        o->defineDefaultProperty(QStringLiteral("transform"), method_transform, 0);
        o->defineDefaultProperty(QStringLiteral("fillText"), method_fillText, 0);
        o->defineDefaultProperty(QStringLiteral("strokeText"), method_strokeText, 0);
        o->defineDefaultProperty(QStringLiteral("translate"), method_translate, 0);
        o->defineDefaultProperty(QStringLiteral("createRadialGradient"), method_createRadialGradient, 0);
        o->defineDefaultProperty(QStringLiteral("shear"), method_shear, 0);
        o->defineDefaultProperty(QStringLiteral("isPointInPath"), method_isPointInPath, 0);
        o->defineDefaultProperty(QStringLiteral("bezierCurveTo"), method_bezierCurveTo, 0);
        o->defineDefaultProperty(QStringLiteral("resetTransform"), method_resetTransform, 0);
        o->defineDefaultProperty(QStringLiteral("arcTo"), method_arcTo, 0);
        o->defineDefaultProperty(QStringLiteral("fillRect"), method_fillRect, 0);
        o->defineDefaultProperty(QStringLiteral("createConicalGradient"), method_createConicalGradient, 0);
        o->defineDefaultProperty(QStringLiteral("drawFocusRing"), method_drawFocusRing, 0);
        o->defineDefaultProperty(QStringLiteral("beginPath"), method_beginPath, 0);
        o->defineDefaultProperty(QStringLiteral("clearRect"), method_clearRect, 0);
        o->defineDefaultProperty(QStringLiteral("rect"), method_rect, 0);
        o->defineDefaultProperty(QStringLiteral("reset"), method_reset, 0);
        o->defineDefaultProperty(QStringLiteral("rotate"), method_rotate, 0);
        o->defineDefaultProperty(QStringLiteral("setCaretSelectionRect"), method_setCaretSelectionRect, 0);
        o->defineDefaultProperty(QStringLiteral("putImageData"), method_putImageData, 0);
        o->defineDefaultProperty(QStringLiteral("getImageData"), method_getImageData, 0);
        o->defineDefaultProperty(QStringLiteral("createLinearGradient"), method_createLinearGradient, 0);
        o->defineDefaultProperty(QStringLiteral("strokeRect"), method_strokeRect, 0);
        o->defineDefaultProperty(QStringLiteral("closePath"), method_closePath, 0);
        o->defineDefaultProperty(QStringLiteral("setLineDash"), method_setLineDash, 0);
        o->defineDefaultProperty(QStringLiteral("getLineDash"), method_getLineDash, 0);
        o->defineAccessorProperty(QStringLiteral("canvas"), QQuickJSContext2DPrototype::method_get_canvas, nullptr);
 
        return o->d();
    }
 
    static QV4::ReturnedValue method_get_canvas(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_restore(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_reset(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_save(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_rotate(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_scale(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_translate(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_setTransform(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_transform(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_resetTransform(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_shear(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_createLinearGradient(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_createRadialGradient(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_createConicalGradient(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_createPattern(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_clearRect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_fillRect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_strokeRect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_arc(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_arcTo(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_beginPath(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_bezierCurveTo(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_clip(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_closePath(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_fill(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_lineTo(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_moveTo(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_quadraticCurveTo(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_rect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_roundedRect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_ellipse(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_text(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_stroke(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_isPointInPath(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_drawFocusRing(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_setCaretSelectionRect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_caretBlinkRate(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_fillText(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_strokeText(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_measureText(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_drawImage(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_createImageData(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_getImageData(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_putImageData(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_setLineDash(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_getLineDash(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
 
};
 
DEFINE_OBJECT_VTABLE(QQuickJSContext2DPrototype);
 
 
struct QQuickContext2DStyle : public QV4::Object
{
    V4_OBJECT2(QQuickContext2DStyle, QV4::Object)
    V4_NEEDS_DESTROY
 
    static QV4::ReturnedValue gradient_proto_addColorStop(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
};
 
 
 
DEFINE_OBJECT_VTABLE(QQuickContext2DStyle);
 
QImage qt_image_convolute_filter(const QImage& src, const QVector<qreal>& weights, int radius = 0)
{
    // weights 3x3 => delta 1
    int delta = radius ? radius : qFloor(qSqrt(weights.size()) / qreal(2));
    int filterDim = 2 * delta + 1;
 
    QImage dst = QImage(src.size(), src.format());
 
    int w = src.width();
    int h = src.height();
 
    const QRgb *sr = (const QRgb *)(src.constBits());
    int srcStride = src.bytesPerLine() / 4;
 
    QRgb *dr = (QRgb*)dst.bits();
    int dstStride = dst.bytesPerLine() / 4;
 
    for (int y = 0; y < h; ++y) {
        for (int x = 0; x < w; ++x) {
            int red = 0;
            int green = 0;
            int blue = 0;
            int alpha = 0;
 
            qreal redF = 0;
            qreal greenF = 0;
            qreal blueF = 0;
            qreal alphaF = 0;
 
            int sy = y;
            int sx = x;
 
            for (int cy = 0; cy < filterDim; ++cy) {
                int scy = sy + cy - delta;
 
                if (scy < 0 || scy >= h)
                    continue;
 
                const QRgb *sry = sr + scy * srcStride;
 
                for (int cx = 0; cx < filterDim; ++cx) {
                    int scx = sx + cx - delta;
 
                    if (scx < 0 || scx >= w)
                        continue;
 
                    const QRgb col = sry[scx];
 
                    if (radius) {
                        red += qRed(col);
                        green += qGreen(col);
                        blue += qBlue(col);
                        alpha += qAlpha(col);
                    } else {
                        qreal wt = weights[cy * filterDim + cx];
 
                        redF += qRed(col) * wt;
                        greenF += qGreen(col) * wt;
                        blueF += qBlue(col) * wt;
                        alphaF += qAlpha(col) * wt;
                    }
                }
            }
 
            if (radius)
                dr[x] = qRgba(qRound(red * weights[0]), qRound(green * weights[0]), qRound(blue * weights[0]), qRound(alpha * weights[0]));
            else
                dr[x] = qRgba(qRound(redF), qRound(greenF), qRound(blueF), qRound(alphaF));
        }
 
        dr += dstStride;
    }
 
    return dst;
}
 
void qt_image_boxblur(QImage& image, int radius, bool quality)
{
    int passes = quality? 3: 1;
    int filterSize = 2 * radius + 1;
    for (int i = 0; i < passes; ++i)
        image = qt_image_convolute_filter(image, QVector<qreal>() << 1.0 / (filterSize * filterSize), radius);
}
 
static QPainter::CompositionMode qt_composite_mode_from_string(const QString &compositeOperator)
{
    if (compositeOperator == QLatin1String("source-over")) {
        return QPainter::CompositionMode_SourceOver;
    } else if (compositeOperator == QLatin1String("source-out")) {
        return QPainter::CompositionMode_SourceOut;
    } else if (compositeOperator == QLatin1String("source-in")) {
        return QPainter::CompositionMode_SourceIn;
    } else if (compositeOperator == QLatin1String("source-atop")) {
        return QPainter::CompositionMode_SourceAtop;
    } else if (compositeOperator == QLatin1String("destination-atop")) {
        return QPainter::CompositionMode_DestinationAtop;
    } else if (compositeOperator == QLatin1String("destination-in")) {
        return QPainter::CompositionMode_DestinationIn;
    } else if (compositeOperator == QLatin1String("destination-out")) {
        return QPainter::CompositionMode_DestinationOut;
    } else if (compositeOperator == QLatin1String("destination-over")) {
        return QPainter::CompositionMode_DestinationOver;
    } else if (compositeOperator == QLatin1String("lighter")) {
        return QPainter::CompositionMode_Plus;
    } else if (compositeOperator == QLatin1String("copy")) {
        return QPainter::CompositionMode_Source;
    } else if (compositeOperator == QLatin1String("xor")) {
        return QPainter::CompositionMode_Xor;
    } else if (compositeOperator == QLatin1String("qt-clear")) {
        return QPainter::CompositionMode_Clear;
    } else if (compositeOperator == QLatin1String("qt-destination")) {
        return QPainter::CompositionMode_Destination;
    } else if (compositeOperator == QLatin1String("qt-multiply")) {
        return QPainter::CompositionMode_Multiply;
    } else if (compositeOperator == QLatin1String("qt-screen")) {
        return QPainter::CompositionMode_Screen;
    } else if (compositeOperator == QLatin1String("qt-overlay")) {
        return QPainter::CompositionMode_Overlay;
    } else if (compositeOperator == QLatin1String("qt-darken")) {
        return QPainter::CompositionMode_Darken;
    } else if (compositeOperator == QLatin1String("qt-lighten")) {
        return QPainter::CompositionMode_Lighten;
    } else if (compositeOperator == QLatin1String("qt-color-dodge")) {
        return QPainter::CompositionMode_ColorDodge;
    } else if (compositeOperator == QLatin1String("qt-color-burn")) {
        return QPainter::CompositionMode_ColorBurn;
    } else if (compositeOperator == QLatin1String("qt-hard-light")) {
        return QPainter::CompositionMode_HardLight;
    } else if (compositeOperator == QLatin1String("qt-soft-light")) {
        return QPainter::CompositionMode_SoftLight;
    } else if (compositeOperator == QLatin1String("qt-difference")) {
        return QPainter::CompositionMode_Difference;
    } else if (compositeOperator == QLatin1String("qt-exclusion")) {
        return QPainter::CompositionMode_Exclusion;
    }
    return QPainter::CompositionMode_SourceOver;
}
 
static QString qt_composite_mode_to_string(QPainter::CompositionMode op)
{
    switch (op) {
    case QPainter::CompositionMode_SourceOver:
        return QStringLiteral("source-over");
    case QPainter::CompositionMode_DestinationOver:
        return QStringLiteral("destination-over");
    case QPainter::CompositionMode_Clear:
        return QStringLiteral("qt-clear");
    case QPainter::CompositionMode_Source:
        return QStringLiteral("copy");
    case QPainter::CompositionMode_Destination:
        return QStringLiteral("qt-destination");
    case QPainter::CompositionMode_SourceIn:
        return QStringLiteral("source-in");
    case QPainter::CompositionMode_DestinationIn:
        return QStringLiteral("destination-in");
    case QPainter::CompositionMode_SourceOut:
        return QStringLiteral("source-out");
    case QPainter::CompositionMode_DestinationOut:
        return QStringLiteral("destination-out");
    case QPainter::CompositionMode_SourceAtop:
        return QStringLiteral("source-atop");
    case QPainter::CompositionMode_DestinationAtop:
        return QStringLiteral("destination-atop");
    case QPainter::CompositionMode_Xor:
        return QStringLiteral("xor");
    case QPainter::CompositionMode_Plus:
        return QStringLiteral("lighter");
    case QPainter::CompositionMode_Multiply:
        return QStringLiteral("qt-multiply");
    case QPainter::CompositionMode_Screen:
        return QStringLiteral("qt-screen");
    case QPainter::CompositionMode_Overlay:
        return QStringLiteral("qt-overlay");
    case QPainter::CompositionMode_Darken:
        return QStringLiteral("qt-darken");
    case QPainter::CompositionMode_Lighten:
        return QStringLiteral("lighter");
    case QPainter::CompositionMode_ColorDodge:
        return QStringLiteral("qt-color-dodge");
    case QPainter::CompositionMode_ColorBurn:
        return QStringLiteral("qt-color-burn");
    case QPainter::CompositionMode_HardLight:
        return QStringLiteral("qt-hard-light");
    case QPainter::CompositionMode_SoftLight:
        return QStringLiteral("qt-soft-light");
    case QPainter::CompositionMode_Difference:
        return QStringLiteral("qt-difference");
    case QPainter::CompositionMode_Exclusion:
        return QStringLiteral("qt-exclusion");
    default:
        break;
    }
    return QString();
}
 
struct QQuickJSContext2DPixelData : public QV4::Object
{
    V4_OBJECT2(QQuickJSContext2DPixelData, QV4::Object)
    V4_NEEDS_DESTROY
 
    static QV4::ReturnedValue virtualGet(const QV4::Managed *m, QV4::PropertyKey id, const QV4::Value *receiver, bool *hasProperty);
    static bool virtualPut(QV4::Managed *m, QV4::PropertyKey  id, const QV4::Value &value, Value *receiver);
 
    static QV4::ReturnedValue proto_get_length(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
};
 
void QV4::Heap::QQuickJSContext2DPixelData::init()
{
    Object::init();
    image = new QImage;
    QV4::Scope scope(internalClass->engine);
    QV4::ScopedObject o(scope, this);
    o->setArrayType(QV4::Heap::ArrayData::Custom);
}
 
DEFINE_OBJECT_VTABLE(QQuickJSContext2DPixelData);
 
struct QQuickJSContext2DImageData : public QV4::Object
{
    V4_OBJECT2(QQuickJSContext2DImageData, QV4::Object)
 
    static QV4::ReturnedValue method_get_width(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_height(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
    static QV4::ReturnedValue method_get_data(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc);
 
};
 
void QV4::Heap::QQuickJSContext2DImageData::init()
{
    Object::init();
    pixelData = QV4::Value::undefinedValue();
 
    QV4::Scope scope(internalClass->engine);
    QV4::ScopedObject o(scope, this);
 
    o->defineAccessorProperty(QStringLiteral("width"), ::QQuickJSContext2DImageData::method_get_width, nullptr);
    o->defineAccessorProperty(QStringLiteral("height"), ::QQuickJSContext2DImageData::method_get_height, nullptr);
    o->defineAccessorProperty(QStringLiteral("data"), ::QQuickJSContext2DImageData::method_get_data, nullptr);
}
 
DEFINE_OBJECT_VTABLE(QQuickJSContext2DImageData);
 
static QV4::ReturnedValue qt_create_image_data(qreal w, qreal h, QV4::ExecutionEngine *v4, QImage&& image)
{
    QV4::Scope scope(v4);
    QQuickContext2DEngineData *ed = engineData(scope.engine);
    QV4::Scoped<QQuickJSContext2DPixelData> pixelData(scope, scope.engine->memoryManager->allocate<QQuickJSContext2DPixelData>());
    QV4::ScopedObject p(scope, ed->pixelArrayProto.value());
    pixelData->setPrototypeOf(p);
 
    if (image.isNull()) {
        *pixelData->d()->image = QImage(qRound(w), qRound(h), QImage::Format_ARGB32);
        pixelData->d()->image->fill(0x00000000);
    } else {
        // After qtbase 88e56d0932a3615231adf40d5ae033e742d72c33, the image size can be off by one.
        Q_ASSERT(qAbs(image.width() - qRound(w * image.devicePixelRatio())) <= 1 && qAbs(image.height() - qRound(h * image.devicePixelRatio())) <= 1);
        *pixelData->d()->image = image.format() == QImage::Format_ARGB32 ? std::move(image) : std::move(image).convertToFormat(QImage::Format_ARGB32);
    }
 
    QV4::Scoped<QQuickJSContext2DImageData> imageData(scope, scope.engine->memoryManager->allocate<QQuickJSContext2DImageData>());
    imageData->d()->pixelData = pixelData.asReturnedValue();
    return imageData.asReturnedValue();
}
 
//static script functions
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_get_canvas(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(QV4::QObjectWrapper::wrap(scope.engine, r->d()->context()->canvas()));
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_restore(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    r->d()->context()->popState();
    RETURN_RESULT(thisObject->asReturnedValue());
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_reset(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    r->d()->context()->reset();
 
    RETURN_RESULT(thisObject->asReturnedValue());
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_save(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    r->d()->context()->pushState();
 
    RETURN_RESULT(*thisObject);
}
 
// transformations
QV4::ReturnedValue QQuickJSContext2DPrototype::method_rotate(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    if (argc >= 1)
        r->d()->context()->rotate(argv[0].toNumber());
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_scale(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
 
    if (argc >= 2)
        r->d()->context()->scale(argv[0].toNumber(), argv[1].toNumber());
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_setTransform(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
 
    if (argc >= 6)
        r->d()->context()->setTransform( argv[0].toNumber()
                                                        , argv[1].toNumber()
                                                        , argv[2].toNumber()
                                                        , argv[3].toNumber()
                                                        , argv[4].toNumber()
                                                        , argv[5].toNumber());
 
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_transform(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    if (argc >= 6)
        r->d()->context()->transform( argv[0].toNumber()
                                                  , argv[1].toNumber()
                                                  , argv[2].toNumber()
                                                  , argv[3].toNumber()
                                                  , argv[4].toNumber()
                                                  , argv[5].toNumber());
 
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_translate(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    if (argc >= 2)
            r->d()->context()->translate(argv[0].toNumber(), argv[1].toNumber());
    RETURN_RESULT(*thisObject);
 
}
 
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_resetTransform(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    r->d()->context()->setTransform(1, 0, 0, 1, 0, 0);
 
    RETURN_RESULT(*thisObject);
 
}
 
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_shear(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    if (argc >= 2)
            r->d()->context()->shear(argv[0].toNumber(), argv[1].toNumber());
 
    RETURN_RESULT(*thisObject);
 
}
// compositing
 
QV4::ReturnedValue QQuickJSContext2D::method_get_globalAlpha(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(QV4::Encode(r->d()->context()->state.globalAlpha));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_globalAlpha(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT_SETTER(r)
 
    double globalAlpha = argc ? argv[0].toNumber() : qt_qnan();
 
 
    if (!qt_is_finite(globalAlpha))
        RETURN_UNDEFINED();
 
    if (globalAlpha >= 0.0 && globalAlpha <= 1.0 && r->d()->context()->state.globalAlpha != globalAlpha) {
        r->d()->context()->state.globalAlpha = globalAlpha;
        r->d()->context()->buffer()->setGlobalAlpha(r->d()->context()->state.globalAlpha);
    }
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2D::method_get_globalCompositeOperation(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(scope.engine->newString(qt_composite_mode_to_string(r->d()->context()->state.globalCompositeOperation)));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_globalCompositeOperation(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT_SETTER(r)
 
    if (!argc)
        THROW_TYPE_ERROR();
 
    QString mode = argv[0].toQString();
    QPainter::CompositionMode cm = qt_composite_mode_from_string(mode);
    if (cm == QPainter::CompositionMode_SourceOver && mode != QLatin1String("source-over"))
        RETURN_UNDEFINED();
 
    if (cm != r->d()->context()->state.globalCompositeOperation) {
        r->d()->context()->state.globalCompositeOperation = cm;
        r->d()->context()->buffer()->setGlobalCompositeOperation(cm);
    }
 
    RETURN_UNDEFINED();
}
 
// colors and styles
QV4::ReturnedValue QQuickJSContext2D::method_get_fillStyle(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    const QColor color = r->d()->context()->state.fillStyle.color().toRgb();
    if (color.isValid()) {
        if (color.alpha() == 255)
            RETURN_RESULT(scope.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');
        QString str = QString::fromLatin1("rgba(%1, %2, %3, %4)").arg(color.red()).arg(color.green()).arg(color.blue()).arg(alphaString);
        RETURN_RESULT(scope.engine->newString(str));
    }
    RETURN_RESULT(r->d()->context()->m_fillStyle.value());
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_fillStyle(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT_SETTER(r)
 
    QV4::ScopedValue value(scope, argc ? argv[0] : QV4::Value::undefinedValue());
 
   if (value->as<Object>()) {
       QColor color = QV4::ExecutionEngine::toVariant(value, QMetaType::fromType<QColor>()).value<QColor>();
       if (color.isValid()) {
           r->d()->context()->state.fillStyle = color;
           r->d()->context()->buffer()->setFillStyle(color);
           r->d()->context()->m_fillStyle.set(scope.engine, value);
       } else {
           QV4::Scoped<QQuickContext2DStyle> style(scope, value->as<QQuickContext2DStyle>());
           if (style && *style->d()->brush != r->d()->context()->state.fillStyle) {
               r->d()->context()->state.fillStyle = *style->d()->brush;
               r->d()->context()->buffer()->setFillStyle(*style->d()->brush, style->d()->patternRepeatX, style->d()->patternRepeatY);
               r->d()->context()->m_fillStyle.set(scope.engine, value);
               r->d()->context()->state.fillPatternRepeatX = style->d()->patternRepeatX;
               r->d()->context()->state.fillPatternRepeatY = style->d()->patternRepeatY;
           }
       }
   } else if (value->isString()) {
       QColor color = qt_color_from_string(value);
       if (color.isValid() && r->d()->context()->state.fillStyle != QBrush(color)) {
            r->d()->context()->state.fillStyle = QBrush(color);
            r->d()->context()->buffer()->setFillStyle(r->d()->context()->state.fillStyle);
            r->d()->context()->m_fillStyle.set(scope.engine, value);
       }
   }
   RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2D::method_get_fillRule(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(scope.engine->fromVariant(r->d()->context()->state.fillRule));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_fillRule(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT_SETTER(r)
 
    QV4::ScopedValue value(scope, argc ? argv[0] : QV4::Value::undefinedValue());
 
    if ((value->isString() && value->toQString() == QLatin1String("WindingFill"))
        || (value->isInt32() && value->integerValue() == Qt::WindingFill)) {
        r->d()->context()->state.fillRule = Qt::WindingFill;
    } else if ((value->isString() && value->toQStringNoThrow() == QLatin1String("OddEvenFill"))
               || (value->isInt32() && value->integerValue() == Qt::OddEvenFill)) {
        r->d()->context()->state.fillRule = Qt::OddEvenFill;
    } else {
        //error
    }
    r->d()->context()->m_path.setFillRule(r->d()->context()->state.fillRule);
    RETURN_UNDEFINED();
}
QV4::ReturnedValue QQuickJSContext2D::method_get_strokeStyle(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    const QColor color = r->d()->context()->state.strokeStyle.color().toRgb();
    if (color.isValid()) {
        if (color.alpha() == 255)
            RETURN_RESULT(scope.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');
        QString str = QString::fromLatin1("rgba(%1, %2, %3, %4)").arg(color.red()).arg(color.green()).arg(color.blue()).arg(alphaString);
        RETURN_RESULT(scope.engine->newString(str));
    }
    RETURN_RESULT(r->d()->context()->m_strokeStyle.value());
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_strokeStyle(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT_SETTER(r)
 
    QV4::ScopedValue value(scope, argc ? argv[0] : QV4::Value::undefinedValue());
 
    if (value->as<Object>()) {
        QColor color = QV4::ExecutionEngine::toVariant(value, QMetaType::fromType<QColor>()).value<QColor>();
        if (color.isValid()) {
            r->d()->context()->state.strokeStyle = color;
            r->d()->context()->buffer()->setStrokeStyle(color);
            r->d()->context()->m_strokeStyle.set(scope.engine, value);
        } else {
            QV4::Scoped<QQuickContext2DStyle> style(scope, value->as<QQuickContext2DStyle>());
            if (style && *style->d()->brush != r->d()->context()->state.strokeStyle) {
                r->d()->context()->state.strokeStyle = *style->d()->brush;
                r->d()->context()->buffer()->setStrokeStyle(*style->d()->brush, style->d()->patternRepeatX, style->d()->patternRepeatY);
                r->d()->context()->m_strokeStyle.set(scope.engine, value);
                r->d()->context()->state.strokePatternRepeatX = style->d()->patternRepeatX;
                r->d()->context()->state.strokePatternRepeatY = style->d()->patternRepeatY;
            } else if (!style && r->d()->context()->state.strokeStyle != QBrush(QColor())) {
                // If there is no style object, then ensure that the strokeStyle is at least
                // QColor in case it was previously set
                r->d()->context()->state.strokeStyle = QBrush(QColor());
                r->d()->context()->buffer()->setStrokeStyle(r->d()->context()->state.strokeStyle);
                r->d()->context()->m_strokeStyle.set(scope.engine, value);
            }
        }
    } else if (value->isString()) {
        QColor color = qt_color_from_string(value);
        if (color.isValid() && r->d()->context()->state.strokeStyle != QBrush(color)) {
             r->d()->context()->state.strokeStyle = QBrush(color);
             r->d()->context()->buffer()->setStrokeStyle(r->d()->context()->state.strokeStyle);
             r->d()->context()->m_strokeStyle.set(scope.engine, value);
        }
    }
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_createLinearGradient(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    if (argc >= 4) {
        qreal x0 = argv[0].toNumber();
        qreal y0 = argv[1].toNumber();
        qreal x1 = argv[2].toNumber();
        qreal y1 = argv[3].toNumber();
 
        if (!qt_is_finite(x0)
         || !qt_is_finite(y0)
         || !qt_is_finite(x1)
         || !qt_is_finite(y1)) {
            THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createLinearGradient(): Incorrect arguments")
        }
        QQuickContext2DEngineData *ed = engineData(scope.engine);
 
        QV4::Scoped<QQuickContext2DStyle> gradient(scope, scope.engine->memoryManager->allocate<QQuickContext2DStyle>());
        QV4::ScopedObject p(scope, ed->gradientProto.value());
        gradient->setPrototypeOf(p);
        *gradient->d()->brush = QLinearGradient(x0, y0, x1, y1);
        RETURN_RESULT(*gradient);
    }
 
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_createRadialGradient(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    if (argc >= 6) {
        qreal x0 = argv[0].toNumber();
        qreal y0 = argv[1].toNumber();
        qreal r0 = argv[2].toNumber();
        qreal x1 = argv[3].toNumber();
        qreal y1 = argv[4].toNumber();
        qreal r1 = argv[5].toNumber();
 
        if (!qt_is_finite(x0)
         || !qt_is_finite(y0)
         || !qt_is_finite(x1)
         || !qt_is_finite(r0)
         || !qt_is_finite(r1)
         || !qt_is_finite(y1)) {
            THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createRadialGradient(): Incorrect arguments")
        }
 
        if (r0 < 0 || r1 < 0)
            THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createRadialGradient(): Incorrect arguments")
 
        QQuickContext2DEngineData *ed = engineData(scope.engine);
 
        QV4::Scoped<QQuickContext2DStyle> gradient(scope, scope.engine->memoryManager->allocate<QQuickContext2DStyle>());
        QV4::ScopedObject p(scope, ed->gradientProto.value());
        gradient->setPrototypeOf(p);
        *gradient->d()->brush = QRadialGradient(QPointF(x1, y1), r1, QPointF(x0, y0), r0);
        RETURN_RESULT(*gradient);
    }
 
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_createConicalGradient(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    if (argc >= 3) {
        qreal x = argv[0].toNumber();
        qreal y = argv[1].toNumber();
        qreal angle = qRadiansToDegrees(argv[2].toNumber());
        if (!qt_is_finite(x) || !qt_is_finite(y)) {
            THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createConicalGradient(): Incorrect arguments");
        }
 
        if (!qt_is_finite(angle)) {
            THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createConicalGradient(): Incorrect arguments");
        }
 
        QQuickContext2DEngineData *ed = engineData(scope.engine);
 
        QV4::Scoped<QQuickContext2DStyle> gradient(scope, scope.engine->memoryManager->allocate<QQuickContext2DStyle>());
        QV4::ScopedObject p(scope, ed->gradientProto.value());
        gradient->setPrototypeOf(p);
        *gradient->d()->brush = QConicalGradient(x, y, angle);
        RETURN_RESULT(*gradient);
    }
 
    RETURN_RESULT(*thisObject);
 
}
QV4::ReturnedValue QQuickJSContext2DPrototype::method_createPattern(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 2) {
        QV4::Scoped<QQuickContext2DStyle> pattern(scope, scope.engine->memoryManager->allocate<QQuickContext2DStyle>());
 
        QColor color = QV4::ExecutionEngine::toVariant(
                    argv[0], QMetaType::fromType<QColor>()).value<QColor>();
        if (color.isValid()) {
            int patternMode = argv[1].toInt32();
            Qt::BrushStyle style = Qt::SolidPattern;
            if (patternMode >= 0 && patternMode < Qt::LinearGradientPattern) {
                style = static_cast<Qt::BrushStyle>(patternMode);
            }
            *pattern->d()->brush = QBrush(color, style);
        } else {
            QImage patternTexture;
 
            if (const QV4::Object *o = argv[0].as<Object>()) {
                QV4::ScopedString s(scope, scope.engine->newString(QStringLiteral("data")));
                QV4::Scoped<QQuickJSContext2DPixelData> pixelData(scope, o->get(s));
                if (!!pixelData) {
                    patternTexture = *pixelData->d()->image;
                }
            } else {
                patternTexture = r->d()->context()->createPixmap(QUrl(argv[0].toQStringNoThrow()))->image();
            }
 
            if (!patternTexture.isNull()) {
                pattern->d()->brush->setTextureImage(patternTexture);
 
                QString repetition = argv[1].toQStringNoThrow();
                if (repetition == QLatin1String("repeat") || repetition.isEmpty()) {
                    pattern->d()->patternRepeatX = true;
                    pattern->d()->patternRepeatY = true;
                } else if (repetition == QLatin1String("repeat-x")) {
                    pattern->d()->patternRepeatX = true;
                    pattern->d()->patternRepeatY = false;
                } else if (repetition == QLatin1String("repeat-y")) {
                    pattern->d()->patternRepeatX = false;
                    pattern->d()->patternRepeatY = true;
                } else if (repetition == QLatin1String("no-repeat")) {
                    pattern->d()->patternRepeatX = false;
                    pattern->d()->patternRepeatY = false;
                } else {
                    //TODO: exception: SYNTAX_ERR
                }
 
            }
        }
 
        RETURN_RESULT(*pattern);
 
    }
    RETURN_UNDEFINED();
}
 
// line styles
QV4::ReturnedValue QQuickJSContext2D::method_get_lineCap(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    switch (r->d()->context()->state.lineCap) {
    case Qt::RoundCap:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("round")));
    case Qt::SquareCap:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("square")));
    case Qt::FlatCap:
    default:
        break;
    }
    RETURN_RESULT(scope.engine->newString(QStringLiteral("butt")));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_lineCap(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    if (!argc)
        return QV4::Encode::undefined();
 
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    QString lineCap = argv[0].toQString();
    Qt::PenCapStyle cap;
    if (lineCap == QLatin1String("round"))
        cap = Qt::RoundCap;
    else if (lineCap == QLatin1String("butt"))
        cap = Qt::FlatCap;
    else if (lineCap == QLatin1String("square"))
        cap = Qt::SquareCap;
    else
        RETURN_UNDEFINED();
 
    if (cap != r->d()->context()->state.lineCap) {
        r->d()->context()->state.lineCap = cap;
        r->d()->context()->buffer()->setLineCap(cap);
    }
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2D::method_get_lineJoin(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    switch (r->d()->context()->state.lineJoin) {
    case Qt::RoundJoin:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("round")));
    case Qt::BevelJoin:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("bevel")));
    case Qt::MiterJoin:
    default:
        break;
    }
    RETURN_RESULT(scope.engine->newString(QStringLiteral("miter")));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_lineJoin(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    if (!argc)
        THROW_TYPE_ERROR();
 
    QString lineJoin = argv[0].toQString();
    Qt::PenJoinStyle join;
    if (lineJoin == QLatin1String("round"))
        join = Qt::RoundJoin;
    else if (lineJoin == QLatin1String("bevel"))
        join = Qt::BevelJoin;
    else if (lineJoin == QLatin1String("miter"))
        join = Qt::SvgMiterJoin;
    else
        RETURN_UNDEFINED();
 
    if (join != r->d()->context()->state.lineJoin) {
        r->d()->context()->state.lineJoin = join;
        r->d()->context()->buffer()->setLineJoin(join);
    }
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2D::method_get_lineWidth(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(QV4::Encode(r->d()->context()->state.lineWidth));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_lineWidth(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    qreal w = argc ? argv[0].toNumber() : -1;
 
    if (w > 0 && qt_is_finite(w) && w != r->d()->context()->state.lineWidth) {
        r->d()->context()->state.lineWidth = w;
        r->d()->context()->buffer()->setLineWidth(w);
    }
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2D::method_get_miterLimit(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(QV4::Encode(r->d()->context()->state.miterLimit));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_miterLimit(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    qreal ml = argc ? argv[0].toNumber() : -1;
 
    if (ml > 0 && qt_is_finite(ml) && ml != r->d()->context()->state.miterLimit) {
        r->d()->context()->state.miterLimit = ml;
        r->d()->context()->buffer()->setMiterLimit(ml);
    }
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_getLineDash(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    const QVector<qreal> pattern = r->d()->context()->state.lineDash;
    QV4::ScopedArrayObject array(scope, scope.engine->newArrayObject(pattern.size()));
    array->arrayReserve(pattern.size());
    for (int i = 0; i < pattern.size(); i++)
        array->put(i, QV4::Value::fromDouble(pattern[i]));
 
    array->setArrayLengthUnchecked(pattern.size());
 
    RETURN_RESULT(*array);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_setLineDash(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    if (!argc)
        RETURN_UNDEFINED();
 
    QV4::ScopedArrayObject array(scope, argv[0]);
    if (!array)
        RETURN_UNDEFINED();
 
    QV4::ScopedValue v(scope);
    const uint arrayLength = array->getLength();
    QVector<qreal> dashes;
    dashes.reserve(arrayLength);
    for (uint i = 0; i < arrayLength; ++i) {
        v = array->get(i);
        const double number = v->toNumber();
 
        if (!qt_is_finite(number) || (number < 0))
                RETURN_UNDEFINED();
 
        dashes.append(v->toNumber());
    }
    if (dashes.size() % 2 != 0) {
        dashes += dashes;
    }
 
    r->d()->context()->state.lineDash = dashes;
    r->d()->context()->buffer()->setLineDash(dashes);
 
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2D::method_get_lineDashOffset(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(QV4::Encode(r->d()->context()->state.lineDashOffset));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_lineDashOffset(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    const qreal offset = argc ? argv[0].toNumber() : -1;
 
    if (qt_is_finite(offset) && offset != r->d()->context()->state.lineDashOffset) {
        r->d()->context()->state.lineDashOffset = offset;
        r->d()->context()->buffer()->setLineDashOffset(offset);
    }
    RETURN_UNDEFINED();
}
 
 
// shadows
QV4::ReturnedValue QQuickJSContext2D::method_get_shadowBlur(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(QV4::Encode(r->d()->context()->state.shadowBlur));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_shadowBlur(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    qreal blur = argc ? argv[0].toNumber() : -1;
 
    if (blur > 0 && qt_is_finite(blur) && blur != r->d()->context()->state.shadowBlur) {
        r->d()->context()->state.shadowBlur = blur;
        r->d()->context()->buffer()->setShadowBlur(blur);
    }
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2D::method_get_shadowColor(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(scope.engine->newString(r->d()->context()->state.shadowColor.name()));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_shadowColor(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    QColor color;
    if (argc)
        color = qt_color_from_string(argv[0]);
 
    if (color.isValid() && color != r->d()->context()->state.shadowColor) {
        r->d()->context()->state.shadowColor = color;
        r->d()->context()->buffer()->setShadowColor(color);
    }
    RETURN_UNDEFINED();
}
 
 
QV4::ReturnedValue QQuickJSContext2D::method_get_shadowOffsetX(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(QV4::Encode(r->d()->context()->state.shadowOffsetX));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_shadowOffsetX(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    qreal offsetX = argc ? argv[0].toNumber() : qt_qnan();
    if (qt_is_finite(offsetX) && offsetX != r->d()->context()->state.shadowOffsetX) {
        r->d()->context()->state.shadowOffsetX = offsetX;
        r->d()->context()->buffer()->setShadowOffsetX(offsetX);
    }
    RETURN_UNDEFINED();
}
QV4::ReturnedValue QQuickJSContext2D::method_get_shadowOffsetY(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(QV4::Encode(r->d()->context()->state.shadowOffsetY));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_shadowOffsetY(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    qreal offsetY = argc ? argv[0].toNumber() : qt_qnan();
    if (qt_is_finite(offsetY) && offsetY != r->d()->context()->state.shadowOffsetY) {
        r->d()->context()->state.shadowOffsetY = offsetY;
        r->d()->context()->buffer()->setShadowOffsetY(offsetY);
    }
    RETURN_UNDEFINED();
}
 
#if QT_CONFIG(quick_path)
QV4::ReturnedValue QQuickJSContext2D::method_get_path(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(r->d()->context()->m_v4path.value());
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_path(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    QV4::ScopedValue value(scope, argc ? argv[0] : QV4::Value::undefinedValue());
    r->d()->context()->beginPath();
    QV4::Scoped<QV4::QObjectWrapper> qobjectWrapper(scope, value);
    if (!!qobjectWrapper) {
        if (QQuickPath *path = qobject_cast<QQuickPath*>(qobjectWrapper->object()))
            r->d()->context()->m_path = path->path();
    } else {
        QString path =value->toQStringNoThrow();
        QQuickSvgParser::parsePathDataFast(path, r->d()->context()->m_path);
    }
    r->d()->context()->m_v4path.set(scope.engine, value);
    RETURN_UNDEFINED();
}
#endif // QT_CONFIG(quick_path)
 
//rects
QV4::ReturnedValue QQuickJSContext2DPrototype::method_clearRect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
 
    if (argc >= 4)
        r->d()->context()->clearRect(argv[0].toNumber(),
                              argv[1].toNumber(),
                              argv[2].toNumber(),
                              argv[3].toNumber());
 
    RETURN_RESULT(*thisObject);
 
}
QV4::ReturnedValue QQuickJSContext2DPrototype::method_fillRect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 4)
        r->d()->context()->fillRect(argv[0].toNumber(), argv[1].toNumber(), argv[2].toNumber(), argv[3].toNumber());
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_strokeRect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 4)
        r->d()->context()->strokeRect(argv[0].toNumber(), argv[1].toNumber(), argv[2].toNumber(), argv[3].toNumber());
 
    RETURN_RESULT(*thisObject);
 
}
 
// Complex shapes (paths) API
QV4::ReturnedValue QQuickJSContext2DPrototype::method_arc(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 5) {
        bool antiClockwise = false;
 
        if (argc == 6)
            antiClockwise = argv[5].toBoolean();
 
        qreal radius = argv[2].toNumber();
 
        if (qt_is_finite(radius) && radius < 0)
           THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "Incorrect argument radius");
 
        r->d()->context()->arc(argv[0].toNumber(),
                        argv[1].toNumber(),
                        radius,
                        argv[3].toNumber(),
                        argv[4].toNumber(),
                        antiClockwise);
    }
 
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_arcTo(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 5) {
        qreal radius = argv[4].toNumber();
 
        if (qt_is_finite(radius) && radius < 0)
           THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "Incorrect argument radius");
 
        r->d()->context()->arcTo(argv[0].toNumber(),
                          argv[1].toNumber(),
                          argv[2].toNumber(),
                          argv[3].toNumber(),
                          radius);
    }
 
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_beginPath(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    r->d()->context()->beginPath();
 
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_bezierCurveTo(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 6) {
        qreal cp1x = argv[0].toNumber();
        qreal cp1y = argv[1].toNumber();
        qreal cp2x = argv[2].toNumber();
        qreal cp2y = argv[3].toNumber();
        qreal x = argv[4].toNumber();
        qreal y = argv[5].toNumber();
 
        if (!qt_is_finite(cp1x) || !qt_is_finite(cp1y) || !qt_is_finite(cp2x) || !qt_is_finite(cp2y) || !qt_is_finite(x) || !qt_is_finite(y))
            RETURN_UNDEFINED();
 
        r->d()->context()->bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
    }
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_clip(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    r->d()->context()->clip();
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_closePath(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    r->d()->context()->closePath();
 
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_fill(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r);
    r->d()->context()->fill();
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_lineTo(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 2) {
        qreal x = argv[0].toNumber();
        qreal y = argv[1].toNumber();
 
        if (!qt_is_finite(x) || !qt_is_finite(y))
            RETURN_UNDEFINED();
 
        r->d()->context()->lineTo(x, y);
    }
 
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_moveTo(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 2) {
        qreal x = argv[0].toNumber();
        qreal y = argv[1].toNumber();
 
        if (!qt_is_finite(x) || !qt_is_finite(y))
            RETURN_UNDEFINED();
        r->d()->context()->moveTo(x, y);
    }
 
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_quadraticCurveTo(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 4) {
        qreal cpx = argv[0].toNumber();
        qreal cpy = argv[1].toNumber();
        qreal x = argv[2].toNumber();
        qreal y = argv[3].toNumber();
 
        if (!qt_is_finite(cpx) || !qt_is_finite(cpy) || !qt_is_finite(x) || !qt_is_finite(y))
            RETURN_UNDEFINED();
 
        r->d()->context()->quadraticCurveTo(cpx, cpy, x, y);
    }
 
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_rect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 4)
        r->d()->context()->rect(argv[0].toNumber(), argv[1].toNumber(), argv[2].toNumber(), argv[3].toNumber());
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_roundedRect(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 6)
        r->d()->context()->roundedRect(argv[0].toNumber()
                              , argv[1].toNumber()
                              , argv[2].toNumber()
                              , argv[3].toNumber()
                              , argv[4].toNumber()
                              , argv[5].toNumber());
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_ellipse(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 4)
        r->d()->context()->ellipse(argv[0].toNumber(), argv[1].toNumber(), argv[2].toNumber(), argv[3].toNumber());
 
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_text(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 3) {
        qreal x = argv[1].toNumber();
        qreal y = argv[2].toNumber();
 
        if (!qt_is_finite(x) || !qt_is_finite(y))
            RETURN_UNDEFINED();
        r->d()->context()->text(argv[0].toQStringNoThrow(), x, y);
    }
 
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_stroke(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    r->d()->context()->stroke();
    RETURN_RESULT(*thisObject);
 
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_isPointInPath(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    bool pointInPath = false;
    if (argc >= 2)
        pointInPath = r->d()->context()->isPointInPath(argv[0].toNumber(), argv[1].toNumber());
    RETURN_RESULT(QV4::Value::fromBoolean(pointInPath).asReturnedValue());
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_drawFocusRing(const QV4::FunctionObject *b, const QV4::Value *, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::drawFocusRing is not supported");
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_setCaretSelectionRect(const QV4::FunctionObject *b, const QV4::Value *, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::setCaretSelectionRect is not supported");
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_caretBlinkRate(const QV4::FunctionObject *b, const QV4::Value *, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::caretBlinkRate is not supported");
}
 
QV4::ReturnedValue QQuickJSContext2D::method_get_font(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    RETURN_RESULT(scope.engine->newString(r->d()->context()->state.font.toString()));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_font(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    QV4::ScopedString s(scope, argc ? argv[0] : QV4::Value::undefinedValue(), QV4::ScopedString::Convert);
    if (scope.hasException())
        RETURN_UNDEFINED();
    QFont font = qt_font_from_string(s->toQString(), r->d()->context()->state.font);
    if (font != r->d()->context()->state.font) {
        r->d()->context()->state.font = font;
    }
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2D::method_get_textAlign(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    switch (r->d()->context()->state.textAlign) {
    case QQuickContext2D::End:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("end")));
    case QQuickContext2D::Left:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("left")));
    case QQuickContext2D::Right:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("right")));
    case QQuickContext2D::Center:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("center")));
    case QQuickContext2D::Start:
    default:
        break;
    }
    RETURN_RESULT(scope.engine->newString(QStringLiteral("start")));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_textAlign(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
 
    QV4::ScopedString s(scope, argc ? argv[0] : QV4::Value::undefinedValue(), QV4::ScopedString::Convert);
    if (scope.hasException())
        RETURN_UNDEFINED();
    QString textAlign = s->toQString();
 
    QQuickContext2D::TextAlignType ta;
    if (textAlign == QLatin1String("start"))
        ta = QQuickContext2D::Start;
    else if (textAlign == QLatin1String("end"))
        ta = QQuickContext2D::End;
    else if (textAlign == QLatin1String("left"))
        ta = QQuickContext2D::Left;
    else if (textAlign == QLatin1String("right"))
        ta = QQuickContext2D::Right;
    else if (textAlign == QLatin1String("center"))
        ta = QQuickContext2D::Center;
    else
        RETURN_UNDEFINED();
 
    if (ta != r->d()->context()->state.textAlign)
        r->d()->context()->state.textAlign = ta;
 
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2D::method_get_textBaseline(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    switch (r->d()->context()->state.textBaseline) {
    case QQuickContext2D::Hanging:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("hanging")));
    case QQuickContext2D::Top:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("top")));
    case QQuickContext2D::Bottom:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("bottom")));
    case QQuickContext2D::Middle:
        RETURN_RESULT(scope.engine->newString(QStringLiteral("middle")));
    case QQuickContext2D::Alphabetic:
    default:
        break;
    }
    RETURN_RESULT(scope.engine->newString(QStringLiteral("alphabetic")));
}
 
QV4::ReturnedValue QQuickJSContext2D::method_set_textBaseline(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT_SETTER(r)
    QV4::ScopedString s(scope, argc ? argv[0] : QV4::Value::undefinedValue(), QV4::ScopedString::Convert);
    if (scope.hasException())
        RETURN_UNDEFINED();
    QString textBaseline = s->toQString();
 
    QQuickContext2D::TextBaseLineType tb;
    if (textBaseline == QLatin1String("alphabetic"))
        tb = QQuickContext2D::Alphabetic;
    else if (textBaseline == QLatin1String("hanging"))
        tb = QQuickContext2D::Hanging;
    else if (textBaseline == QLatin1String("top"))
        tb = QQuickContext2D::Top;
    else if (textBaseline == QLatin1String("bottom"))
        tb = QQuickContext2D::Bottom;
    else if (textBaseline == QLatin1String("middle"))
        tb = QQuickContext2D::Middle;
    else
        RETURN_UNDEFINED();
 
    if (tb != r->d()->context()->state.textBaseline)
        r->d()->context()->state.textBaseline = tb;
 
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_fillText(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 3) {
        qreal x = argv[1].toNumber();
        qreal y = argv[2].toNumber();
        if (!qt_is_finite(x) || !qt_is_finite(y))
            RETURN_UNDEFINED();
        QPainterPath textPath = r->d()->context()->createTextGlyphs(x, y, argv[0].toQStringNoThrow());
        r->d()->context()->buffer()->fill(textPath);
    }
 
    RETURN_RESULT(*thisObject);
}
QV4::ReturnedValue QQuickJSContext2DPrototype::method_strokeText(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 3)
        r->d()->context()->drawText(argv[0].toQStringNoThrow(), argv[1].toNumber(), argv[2].toNumber(), false);
 
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_measureText(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    if (argc >= 1) {
        QFontMetrics fm(r->d()->context()->state.font);
        uint width = fm.horizontalAdvance(argv[0].toQStringNoThrow());
        QV4::ScopedObject tm(scope, scope.engine->newObject());
        tm->put(QV4::ScopedString(scope, scope.engine->newIdentifier(QStringLiteral("width"))).getPointer(),
                QV4::ScopedValue(scope, QV4::Value::fromDouble(width)));
        RETURN_RESULT(*tm);
    }
    RETURN_UNDEFINED();
}
 
// drawing images
QV4::ReturnedValue QQuickJSContext2DPrototype::method_drawImage(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, *thisObject);
    CHECK_CONTEXT(r)
 
    qreal sx, sy, sw, sh, dx, dy, dw, dh;
 
    if (!argc)
        RETURN_UNDEFINED();
 
    //FIXME:This function should be moved to QQuickContext2D::drawImage(...)
    if (!r->d()->context()->state.invertibleCTM)
        RETURN_UNDEFINED();
 
    QQmlRefPointer<QQuickCanvasPixmap> pixmap;
 
    QV4::ScopedValue arg(scope, argv[0]);
    if (arg->isString()) {
        QUrl url(arg->toQString());
        if (!url.isValid())
            THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
 
        pixmap = r->d()->context()->createPixmap(url);
    } else if (arg->isObject()) {
        QV4::Scoped<QV4::QObjectWrapper> qobjectWrapper(scope, arg);
        if (!!qobjectWrapper) {
            if (QQuickImage *imageItem = qobject_cast<QQuickImage*>(qobjectWrapper->object())) {
                pixmap = r->d()->context()->createPixmap(imageItem->source());
            } else if (QQuickCanvasItem *canvas = qobject_cast<QQuickCanvasItem*>(qobjectWrapper->object())) {
                QImage img = canvas->toImage();
                if (!img.isNull())
                    pixmap.adopt(new QQuickCanvasPixmap(img));
            } else {
                THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
            }
        } else {
            QV4::Scoped<QQuickJSContext2DImageData> imageData(scope, arg);
            if (!!imageData) {
                QV4::Scoped<QQuickJSContext2DPixelData> pix(scope, imageData->d()->pixelData.as<QQuickJSContext2DPixelData>());
                if (pix && !pix->d()->image->isNull()) {
                    pixmap.adopt(new QQuickCanvasPixmap(*pix->d()->image));
                } else {
                    THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
                }
            } else {
                QUrl url(arg->toQStringNoThrow());
                if (url.isValid())
                    pixmap = r->d()->context()->createPixmap(url);
                else
                    THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
            }
        }
    } else {
        THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
    }
 
    if (pixmap.isNull() || !pixmap->isValid())
        RETURN_UNDEFINED();
 
    if (argc >= 9) {
        sx = argv[1].toNumber();
        sy = argv[2].toNumber();
        sw = argv[3].toNumber();
        sh = argv[4].toNumber();
        dx = argv[5].toNumber();
        dy = argv[6].toNumber();
        dw = argv[7].toNumber();
        dh = argv[8].toNumber();
    } else if (argc >= 5) {
        sx = 0;
        sy = 0;
        sw = pixmap->width();
        sh = pixmap->height();
        dx = argv[1].toNumber();
        dy = argv[2].toNumber();
        dw = argv[3].toNumber();
        dh = argv[4].toNumber();
    } else if (argc >= 3) {
        dx = argv[1].toNumber();
        dy = argv[2].toNumber();
        sx = 0;
        sy = 0;
        sw = pixmap->width();
        sh = pixmap->height();
        dw = sw;
        dh = sh;
    } else {
        RETURN_UNDEFINED();
    }
 
    if (!qt_is_finite(sx)
     || !qt_is_finite(sy)
     || !qt_is_finite(sw)
     || !qt_is_finite(sh)
     || !qt_is_finite(dx)
     || !qt_is_finite(dy)
     || !qt_is_finite(dw)
     || !qt_is_finite(dh))
        RETURN_UNDEFINED();
 
    if (sx < 0
    || sy < 0
    || sw == 0
    || sh == 0
    || sx + sw > pixmap->width()
    || sy + sh > pixmap->height()
    || sx + sw < 0 || sy + sh < 0) {
            THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "drawImage(), index size error");
    }
 
    r->d()->context()->buffer()->drawPixmap(pixmap, QRectF(sx, sy, sw, sh), QRectF(dx, dy, dw, dh));
 
    RETURN_RESULT(*thisObject);
}
 
// pixel manipulation
QV4::ReturnedValue QQuickJSContext2DImageData::method_get_width(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2DImageData> imageData(scope, *thisObject);
    if (!imageData)
        THROW_TYPE_ERROR();
    QV4::Scoped<QQuickJSContext2DPixelData> r(scope, imageData->d()->pixelData.as<QQuickJSContext2DPixelData>());
    int width = r ? r->d()->image->width() : 0;
    RETURN_RESULT(QV4::Encode(width));
}
 
QV4::ReturnedValue QQuickJSContext2DImageData::method_get_height(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2DImageData> imageData(scope, *thisObject);
    if (!imageData)
        THROW_TYPE_ERROR();
    QV4::Scoped<QQuickJSContext2DPixelData> r(scope, imageData->d()->pixelData.as<QQuickJSContext2DPixelData>());
    int height = r ? r->d()->image->height() : 0;
    RETURN_RESULT(QV4::Encode(height));
}
 
QV4::ReturnedValue QQuickJSContext2DImageData::method_get_data(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2DImageData> imageData(scope, *thisObject);
    if (!imageData)
        THROW_TYPE_ERROR();
    RETURN_RESULT(imageData->d()->pixelData);
}
 
QV4::ReturnedValue QQuickJSContext2DPixelData::proto_get_length(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2DPixelData> r(scope, thisObject->as<QQuickJSContext2DPixelData>());
    if (!r || r->d()->image->isNull())
        RETURN_UNDEFINED();
 
    RETURN_RESULT(QV4::Encode(r->d()->image->width() * r->d()->image->height() * 4));
}
 
QV4::ReturnedValue QQuickJSContext2DPixelData::virtualGet(const QV4::Managed *m, QV4::PropertyKey id, const QV4::Value *receiver, bool *hasProperty)
{
    if (!id.isArrayIndex())
        return QV4::Object::virtualGet(m, id, receiver, hasProperty);
 
    uint index = id.asArrayIndex();
    Q_ASSERT(m->as<QQuickJSContext2DPixelData>());
    QV4::ExecutionEngine *v4 = static_cast<const QQuickJSContext2DPixelData *>(m)->engine();
    QV4::Scope scope(v4);
    QV4::Scoped<QQuickJSContext2DPixelData> r(scope, static_cast<const QQuickJSContext2DPixelData *>(m));
 
    if (index < static_cast<quint32>(r->d()->image->width() * r->d()->image->height() * 4)) {
        if (hasProperty)
            *hasProperty = true;
        const quint32 w = r->d()->image->width();
        const quint32 row = (index / 4) / w;
        const quint32 col = (index / 4) % w;
        const QRgb* pixel = reinterpret_cast<const QRgb*>(r->d()->image->constScanLine(row));
        pixel += col;
        switch (index % 4) {
        case 0:
            return QV4::Encode(qRed(*pixel));
        case 1:
            return QV4::Encode(qGreen(*pixel));
        case 2:
            return QV4::Encode(qBlue(*pixel));
        case 3:
            return QV4::Encode(qAlpha(*pixel));
        }
    }
 
    if (hasProperty)
        *hasProperty = false;
    return QV4::Encode::undefined();
}
 
bool QQuickJSContext2DPixelData::virtualPut(QV4::Managed *m, QV4::PropertyKey id, const QV4::Value &value, QV4::Value *receiver)
{
    if (!id.isArrayIndex())
        return Object::virtualPut(m, id, value, receiver);
 
    Q_ASSERT(m->as<QQuickJSContext2DPixelData>());
    QV4::ExecutionEngine *v4 = static_cast<QQuickJSContext2DPixelData *>(m)->engine();
    QV4::Scope scope(v4);
    if (scope.hasException())
        return false;
 
    uint index = id.asArrayIndex();
    QV4::Scoped<QQuickJSContext2DPixelData> r(scope, static_cast<QQuickJSContext2DPixelData *>(m));
 
    const int v = value.toInt32();
    if (r && index < static_cast<quint32>(r->d()->image->width() * r->d()->image->height() * 4) && v >= 0 && v <= 255) {
        const quint32 w = r->d()->image->width();
        const quint32 row = (index / 4) / w;
        const quint32 col = (index / 4) % w;
 
        QRgb* pixel = reinterpret_cast<QRgb*>(r->d()->image->scanLine(row));
        pixel += col;
        switch (index % 4) {
        case 0:
            *pixel = qRgba(v, qGreen(*pixel), qBlue(*pixel), qAlpha(*pixel));
            break;
        case 1:
            *pixel = qRgba(qRed(*pixel), v, qBlue(*pixel), qAlpha(*pixel));
            break;
        case 2:
            *pixel = qRgba(qRed(*pixel), qGreen(*pixel), v, qAlpha(*pixel));
            break;
        case 3:
            *pixel = qRgba(qRed(*pixel), qGreen(*pixel), qBlue(*pixel), v);
            break;
        }
        return true;
    }
 
    return false;
}
QV4::ReturnedValue QQuickJSContext2DPrototype::method_createImageData(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    if (argc == 1) {
        QV4::ScopedValue arg0(scope, argv[0]);
        QV4::Scoped<QQuickJSContext2DImageData> imgData(scope, arg0);
        if (!!imgData) {
            QV4::Scoped<QQuickJSContext2DPixelData> pa(scope, imgData->d()->pixelData.as<QQuickJSContext2DPixelData>());
            if (pa) {
                qreal w = pa->d()->image->width();
                qreal h = pa->d()->image->height();
                RETURN_RESULT(qt_create_image_data(w, h, scope.engine, QImage()));
            }
        } else if (arg0->isString()) {
            QImage image = r->d()->context()->createPixmap(QUrl(arg0->toQStringNoThrow()))->image();
            RETURN_RESULT(qt_create_image_data(image.width(), image.height(), scope.engine, std::move(image)));
        }
    } else if (argc == 2) {
        qreal w = argv[0].toNumber();
        qreal h = argv[1].toNumber();
 
        if (!qt_is_finite(w) || !qt_is_finite(h))
            THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createImageData(): invalid arguments");
 
        if (w > 0 && h > 0)
            RETURN_RESULT(qt_create_image_data(w, h, scope.engine, QImage()));
        else
            THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createImageData(): invalid arguments");
    }
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_getImageData(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
 
    if (argc >= 4) {
        qreal x = argv[0].toNumber();
        qreal y = argv[1].toNumber();
        qreal w = argv[2].toNumber();
        qreal h = argv[3].toNumber();
        if (!qt_is_finite(x) || !qt_is_finite(y) || !qt_is_finite(w) || !qt_is_finite(h))
            THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "getImageData(): Invalid arguments");
 
        if (w <= 0 || h <= 0)
            THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "getImageData(): Invalid arguments");
 
        QImage image = r->d()->context()->canvas()->toImage(QRectF(x, y, w, h));
        RETURN_RESULT(qt_create_image_data(w, h, scope.engine, std::move(image)));
    }
    RETURN_RESULT(QV4::Encode::null());
}
 
QV4::ReturnedValue QQuickJSContext2DPrototype::method_putImageData(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickJSContext2D> r(scope, thisObject->as<QQuickJSContext2D>());
    CHECK_CONTEXT(r)
    if (argc < 7)
        RETURN_UNDEFINED();
 
    QV4::ScopedValue arg0(scope, argv[0]);
    if (!arg0->isObject())
        THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "Context2D::putImageData, the image data type mismatch");
 
    qreal dx = argv[1].toNumber();
    qreal dy = argv[2].toNumber();
    qreal w, h, dirtyX, dirtyY, dirtyWidth, dirtyHeight;
 
    if (!qt_is_finite(dx) || !qt_is_finite(dy))
        THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
 
    QV4::Scoped<QQuickJSContext2DImageData> imageData(scope, arg0);
    if (!imageData)
        RETURN_UNDEFINED();
 
    QV4::Scoped<QQuickJSContext2DPixelData> pixelArray(scope, imageData->d()->pixelData.as<QQuickJSContext2DPixelData>());
    if (pixelArray) {
        w = pixelArray->d()->image->width();
        h = pixelArray->d()->image->height();
 
        if (argc == 7) {
            dirtyX = argv[3].toNumber();
            dirtyY = argv[4].toNumber();
            dirtyWidth = argv[5].toNumber();
            dirtyHeight = argv[6].toNumber();
 
            if (!qt_is_finite(dirtyX) || !qt_is_finite(dirtyY) || !qt_is_finite(dirtyWidth) || !qt_is_finite(dirtyHeight))
                THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
 
 
            if (dirtyWidth < 0) {
                dirtyX = dirtyX+dirtyWidth;
                dirtyWidth = -dirtyWidth;
            }
 
            if (dirtyHeight < 0) {
                dirtyY = dirtyY+dirtyHeight;
                dirtyHeight = -dirtyHeight;
            }
 
            if (dirtyX < 0) {
                dirtyWidth = dirtyWidth+dirtyX;
                dirtyX = 0;
            }
 
            if (dirtyY < 0) {
                dirtyHeight = dirtyHeight+dirtyY;
                dirtyY = 0;
            }
 
            if (dirtyX+dirtyWidth > w) {
                dirtyWidth = w - dirtyX;
            }
 
            if (dirtyY+dirtyHeight > h) {
                dirtyHeight = h - dirtyY;
            }
 
            if (dirtyWidth <=0 || dirtyHeight <= 0)
                RETURN_UNDEFINED();
        } else {
            dirtyX = 0;
            dirtyY = 0;
            dirtyWidth = w;
            dirtyHeight = h;
        }
 
        QImage image = pixelArray->d()->image->copy(dirtyX, dirtyY, dirtyWidth, dirtyHeight);
        r->d()->context()->buffer()->drawImage(image, QRectF(dirtyX, dirtyY, dirtyWidth, dirtyHeight), QRectF(dx, dy, dirtyWidth, dirtyHeight));
    }
 
    RETURN_RESULT(*thisObject);
}
 
QV4::ReturnedValue QQuickContext2DStyle::gradient_proto_addColorStop(const QV4::FunctionObject *b, const QV4::Value *thisObject, const QV4::Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QQuickContext2DStyle> style(scope, thisObject->as<QQuickContext2DStyle>());
    if (!style)
        THROW_GENERIC_ERROR("Not a CanvasGradient object");
 
    if (argc == 2) {
 
        if (!style->d()->brush->gradient())
            THROW_GENERIC_ERROR("Not a valid CanvasGradient object, can't get the gradient information");
        QGradient gradient = *(style->d()->brush->gradient());
        qreal pos = argv[0].toNumber();
        QColor color;
 
        if (argv[1].as<Object>()) {
            color = QV4::ExecutionEngine::toVariant(
                        argv[1], QMetaType::fromType<QColor>()).value<QColor>();
        } else {
            color = qt_color_from_string(argv[1]);
        }
        if (pos < 0.0 || pos > 1.0 || !qt_is_finite(pos)) {
            THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "CanvasGradient: parameter offset out of range");
        }
 
        if (color.isValid()) {
            gradient.setColorAt(pos, color);
        } else {
            THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "CanvasGradient: parameter color is not a valid color string");
        }
        *style->d()->brush = gradient;
    }
 
    return thisObject->asReturnedValue();
}
 
void QQuickContext2D::scale(qreal x,  qreal y)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(x) || !qt_is_finite(y))
        return;
 
    QTransform newTransform = state.matrix;
    newTransform.scale(x, y);
 
    if (!newTransform.isInvertible()) {
        state.invertibleCTM = false;
        return;
    }
 
    state.matrix = newTransform;
    buffer()->updateMatrix(state.matrix);
    m_path = QTransform().scale(1.0 / x, 1.0 / y).map(m_path);
}
 
void QQuickContext2D::rotate(qreal angle)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(angle))
        return;
 
    QTransform newTransform =state.matrix;
    newTransform.rotate(qRadiansToDegrees(angle));
 
    if (!newTransform.isInvertible()) {
        state.invertibleCTM = false;
        return;
    }
 
    state.matrix = newTransform;
    buffer()->updateMatrix(state.matrix);
    m_path = QTransform().rotate(-qRadiansToDegrees(angle)).map(m_path);
}
 
void QQuickContext2D::shear(qreal h, qreal v)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(h) || !qt_is_finite(v))
        return ;
 
    QTransform newTransform = state.matrix;
    newTransform.shear(h, v);
 
    if (!newTransform.isInvertible()) {
        state.invertibleCTM = false;
        return;
    }
 
    state.matrix = newTransform;
    buffer()->updateMatrix(state.matrix);
    m_path = QTransform().shear(-h, -v).map(m_path);
}
 
void QQuickContext2D::translate(qreal x, qreal y)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(x) || !qt_is_finite(y))
        return ;
 
    QTransform newTransform = state.matrix;
    newTransform.translate(x, y);
 
    if (!newTransform.isInvertible()) {
        state.invertibleCTM = false;
        return;
    }
 
    state.matrix = newTransform;
    buffer()->updateMatrix(state.matrix);
    m_path = QTransform().translate(-x, -y).map(m_path);
}
 
void QQuickContext2D::transform(qreal a, qreal b, qreal c, qreal d, qreal e, qreal f)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(a) || !qt_is_finite(b) || !qt_is_finite(c) || !qt_is_finite(d) || !qt_is_finite(e) || !qt_is_finite(f))
        return;
 
    QTransform transform(a, b, c, d, e, f);
    QTransform newTransform = state.matrix * transform;
 
    if (!newTransform.isInvertible()) {
        state.invertibleCTM = false;
        return;
    }
    state.matrix = newTransform;
    buffer()->updateMatrix(state.matrix);
    m_path = transform.inverted().map(m_path);
}
 
void QQuickContext2D::setTransform(qreal a, qreal b, qreal c, qreal d, qreal e, qreal f)
{
    if (!qt_is_finite(a) || !qt_is_finite(b) || !qt_is_finite(c) || !qt_is_finite(d) || !qt_is_finite(e) || !qt_is_finite(f))
        return;
 
    QTransform ctm = state.matrix;
    if (!ctm.isInvertible())
        return;
 
    state.matrix = ctm.inverted() * state.matrix;
    m_path = ctm.map(m_path);
    state.invertibleCTM = true;
    transform(a, b, c, d, e, f);
}
 
void QQuickContext2D::fill()
{
    if (!state.invertibleCTM)
        return;
 
    if (!m_path.elementCount())
        return;
 
    m_path.setFillRule(state.fillRule);
    buffer()->fill(m_path);
}
 
void QQuickContext2D::clip()
{
    if (!state.invertibleCTM)
        return;
 
    QPainterPath clipPath = m_path;
    clipPath.closeSubpath();
    if (state.clip) {
        state.clipPath = clipPath.intersected(state.clipPath);
    } else {
        state.clip = true;
        state.clipPath = clipPath;
    }
    buffer()->clip(state.clip, state.clipPath);
}
 
void QQuickContext2D::stroke()
{
    if (!state.invertibleCTM)
        return;
 
    if (!m_path.elementCount())
        return;
 
    buffer()->stroke(m_path);
}
 
void QQuickContext2D::fillRect(qreal x, qreal y, qreal w, qreal h)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(x) || !qt_is_finite(y) || !qt_is_finite(w) || !qt_is_finite(h))
        return;
 
    buffer()->fillRect(QRectF(x, y, w, h));
}
 
void QQuickContext2D::strokeRect(qreal x, qreal y, qreal w, qreal h)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(x) || !qt_is_finite(y) || !qt_is_finite(w) || !qt_is_finite(h))
        return;
 
    buffer()->strokeRect(QRectF(x, y, w, h));
}
 
void QQuickContext2D::clearRect(qreal x, qreal y, qreal w, qreal h)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(x) || !qt_is_finite(y) || !qt_is_finite(w) || !qt_is_finite(h))
        return;
 
    buffer()->clearRect(QRectF(x, y, w, h));
}
 
void QQuickContext2D::drawText(const QString& text, qreal x, qreal y, bool fill)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(x) || !qt_is_finite(y))
        return;
 
    QPainterPath textPath = createTextGlyphs(x, y, text);
    if (fill)
        buffer()->fill(textPath);
    else
        buffer()->stroke(textPath);
}
 
 
void QQuickContext2D::beginPath()
{
    if (!m_path.elementCount())
        return;
    m_path = QPainterPath();
}
 
void QQuickContext2D::closePath()
{
    if (!m_path.elementCount())
        return;
 
    QRectF boundRect = m_path.boundingRect();
    if (boundRect.width() || boundRect.height())
        m_path.closeSubpath();
    //FIXME:QPainterPath set the current point to (0,0) after close subpath
    //should be the first point of the previous subpath
}
 
void QQuickContext2D::moveTo( qreal x, qreal y)
{
    if (!state.invertibleCTM)
        return;
 
    //FIXME: moveTo should not close the previous subpath
    m_path.moveTo(QPointF(x, y));
}
 
void QQuickContext2D::lineTo( qreal x, qreal y)
{
    if (!state.invertibleCTM)
        return;
 
    QPointF pt(x, y);
 
    if (!m_path.elementCount())
        m_path.moveTo(pt);
    else if (m_path.currentPosition() != pt)
        m_path.lineTo(pt);
}
 
void QQuickContext2D::quadraticCurveTo(qreal cpx, qreal cpy,
                                           qreal x, qreal y)
{
    if (!state.invertibleCTM)
        return;
 
    if (!m_path.elementCount())
        m_path.moveTo(QPointF(cpx, cpy));
 
    QPointF pt(x, y);
    if (m_path.currentPosition() != pt)
        m_path.quadTo(QPointF(cpx, cpy), pt);
}
 
void QQuickContext2D::bezierCurveTo(qreal cp1x, qreal cp1y,
                                        qreal cp2x, qreal cp2y,
                                        qreal x, qreal y)
{
    if (!state.invertibleCTM)
        return;
 
    if (!m_path.elementCount())
        m_path.moveTo(QPointF(cp1x, cp1y));
 
    QPointF pt(x, y);
    if (m_path.currentPosition() != pt)
        m_path.cubicTo(QPointF(cp1x, cp1y), QPointF(cp2x, cp2y),  pt);
}
 
void QQuickContext2D::addArcTo(const QPointF& p1, const QPointF& p2, qreal radius)
{
    QPointF p0(m_path.currentPosition());
 
    QPointF p1p0((p0.x() - p1.x()), (p0.y() - p1.y()));
    QPointF p1p2((p2.x() - p1.x()), (p2.y() - p1.y()));
    qreal p1p0_length = std::hypot(p1p0.x(), p1p0.y());
    qreal p1p2_length = std::hypot(p1p2.x(), p1p2.y());
 
    qreal cos_phi = QPointF::dotProduct(p1p0, p1p2) / (p1p0_length * p1p2_length);
 
    // The points p0, p1, and p2 are on the same straight line (HTML5, 4.8.11.1.8)
    // We could have used areCollinear() here, but since we're reusing
    // the variables computed above later on we keep this logic.
    if (qFuzzyCompare(std::abs(cos_phi), 1.0)) {
        m_path.lineTo(p1);
        return;
    }
 
    qreal tangent = radius / std::tan(std::acos(cos_phi) / 2);
    qreal factor_p1p0 = tangent / p1p0_length;
    QPointF t_p1p0((p1.x() + factor_p1p0 * p1p0.x()), (p1.y() + factor_p1p0 * p1p0.y()));
 
    QPointF orth_p1p0(p1p0.y(), -p1p0.x());
    qreal orth_p1p0_length = std::hypot(orth_p1p0.x(), orth_p1p0.y());
    qreal factor_ra = radius / orth_p1p0_length;
 
    // angle between orth_p1p0 and p1p2 to get the right vector orthographic to p1p0
    qreal cos_alpha = QPointF::dotProduct(orth_p1p0, p1p2) / (orth_p1p0_length * p1p2_length);
    if (cos_alpha < 0.f)
        orth_p1p0 = QPointF(-orth_p1p0.x(), -orth_p1p0.y());
 
    QPointF p((t_p1p0.x() + factor_ra * orth_p1p0.x()), (t_p1p0.y() + factor_ra * orth_p1p0.y()));
 
    // calculate angles for addArc
    orth_p1p0 = QPointF(-orth_p1p0.x(), -orth_p1p0.y());
    qreal sa = std::atan2(orth_p1p0.y(), orth_p1p0.x());
 
    // anticlockwise logic
    bool anticlockwise = false;
 
    qreal factor_p1p2 = tangent / p1p2_length;
    QPointF t_p1p2((p1.x() + factor_p1p2 * p1p2.x()), (p1.y() + factor_p1p2 * p1p2.y()));
    QPointF orth_p1p2((t_p1p2.x() - p.x()), (t_p1p2.y() - p.y()));
    qreal ea = std::atan2(orth_p1p2.y(), orth_p1p2.x());
    if ((sa > ea) && ((sa - ea) < M_PI))
        anticlockwise = true;
    if ((sa < ea) && ((ea - sa) > M_PI))
        anticlockwise = true;
 
    arc(p.x(), p.y(), radius, sa, ea, anticlockwise);
}
 
void QQuickContext2D::arcTo(qreal x1, qreal y1,
                                qreal x2, qreal y2,
                                qreal radius)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(x1) || !qt_is_finite(y1) || !qt_is_finite(x2) || !qt_is_finite(y2) || !qt_is_finite(radius))
        return;
 
    QPointF st(x1, y1);
    QPointF end(x2, y2);
 
    if (!m_path.elementCount())
        m_path.moveTo(st);
    else if (st == m_path.currentPosition() || st == end || !radius)
        lineTo(x1, y1);
    else
        addArcTo(st, end, radius);
 }
 
void QQuickContext2D::rect(qreal x, qreal y, qreal w, qreal h)
{
    if (!state.invertibleCTM)
        return;
    if (!qt_is_finite(x) || !qt_is_finite(y) || !qt_is_finite(w) || !qt_is_finite(h))
        return;
 
    if (!w && !h) {
        m_path.moveTo(x, y);
        return;
    }
    m_path.addRect(x, y, w, h);
}
 
void QQuickContext2D::roundedRect(qreal x, qreal y,
                               qreal w, qreal h,
                               qreal xr, qreal yr)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(x) || !qt_is_finite(y) || !qt_is_finite(w) || !qt_is_finite(h) || !qt_is_finite(xr) || !qt_is_finite(yr))
        return;
 
    if (!w && !h) {
        m_path.moveTo(x, y);
        return;
    }
    m_path.addRoundedRect(QRectF(x, y, w, h), xr, yr, Qt::AbsoluteSize);
}
 
void QQuickContext2D::ellipse(qreal x, qreal y,
                           qreal w, qreal h)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(x) || !qt_is_finite(y) || !qt_is_finite(w) || !qt_is_finite(h))
        return;
 
    if (!w && !h) {
        m_path.moveTo(x, y);
        return;
    }
 
    m_path.addEllipse(x, y, w, h);
}
 
void QQuickContext2D::text(const QString& str, qreal x, qreal y)
{
    if (!state.invertibleCTM)
        return;
 
    QPainterPath path;
    path.addText(x, y, state.font, str);
    m_path.addPath(path);
}
 
void QQuickContext2D::arc(qreal xc, qreal yc, qreal radius, qreal sar, qreal ear, bool antiClockWise)
{
    if (!state.invertibleCTM)
        return;
 
    if (!qt_is_finite(xc) || !qt_is_finite(yc) || !qt_is_finite(sar) || !qt_is_finite(ear) || !qt_is_finite(radius))
        return;
 
    if (sar == ear)
        return;
 
 
    //### HACK
 
    // In Qt we don't switch the coordinate system for degrees
    // and still use the 0,0 as bottom left for degrees so we need
    // to switch
    sar = -sar;
    ear = -ear;
    antiClockWise = !antiClockWise;
    //end hack
 
    float sa = qRadiansToDegrees(sar);
    float ea = qRadiansToDegrees(ear);
 
    double span = 0;
 
    double xs     = xc - radius;
    double ys     = yc - radius;
    double width  = radius*2;
    double height = radius*2;
    if ((!antiClockWise && (ea - sa >= 360)) || (antiClockWise && (sa - ea >= 360)))
        // If the anticlockwise argument is false and endAngle-startAngle is equal to or greater than 2*PI, or, if the
        // anticlockwise argument is true and startAngle-endAngle is equal to or greater than 2*PI, then the arc is the whole
        // circumference of this circle.
        span = 360;
    else {
        if (!antiClockWise && (ea < sa)) {
            span += 360;
        } else if (antiClockWise && (sa < ea)) {
            span -= 360;
        }
        //### this is also due to switched coordinate system
        // we would end up with a 0 span instead of 360
        if (!(qFuzzyCompare(span + (ea - sa) + 1, 1) &&
              qFuzzyCompare(qAbs(span), 360))) {
            span   += ea - sa;
        }
    }
 
    // If the path is empty, move to where the arc will start to avoid painting a line from (0,0)
    if (!m_path.elementCount())
        m_path.arcMoveTo(xs, ys, width, height, sa);
    else if (!radius) {
        m_path.lineTo(xc, yc);
        return;
    }
 
    m_path.arcTo(xs, ys, width, height, sa, span);
}
 
int baseLineOffset(QQuickContext2D::TextBaseLineType value, const QFontMetrics &metrics)
{
    int offset = 0;
    switch (value) {
    case QQuickContext2D::Top:
    case QQuickContext2D::Hanging:
        break;
    case QQuickContext2D::Middle:
        offset = (metrics.ascent() >> 1) + metrics.height() - metrics.ascent();
        break;
    case QQuickContext2D::Alphabetic:
        offset = metrics.ascent();
        break;
    case QQuickContext2D::Bottom:
        offset = metrics.height();
       break;
    }
    return offset;
}
 
static int textAlignOffset(QQuickContext2D::TextAlignType value, const QFontMetrics &metrics, const QString &text)
{
    int offset = 0;
    if (value == QQuickContext2D::Start)
        value = QGuiApplication::layoutDirection() == Qt::LeftToRight ? QQuickContext2D::Left : QQuickContext2D::Right;
    else if (value == QQuickContext2D::End)
        value = QGuiApplication::layoutDirection() == Qt::LeftToRight ? QQuickContext2D::Right: QQuickContext2D::Left;
    switch (value) {
    case QQuickContext2D::Center:
        offset = metrics.horizontalAdvance(text) / 2;
        break;
    case QQuickContext2D::Right:
        offset = metrics.horizontalAdvance(text);
        break;
    case QQuickContext2D::Left:
    default:
        break;
    }
    return offset;
}
 
void QQuickContext2D::setGrabbedImage(const QImage& grab)
{
    m_grabbedImage = grab;
    m_grabbed = true;
}
 
QQmlRefPointer<QQuickCanvasPixmap> QQuickContext2D::createPixmap(const QUrl& url, QSizeF sourceSize)
{
    return m_canvas->loadedPixmap(url, sourceSize);
}
 
QPainterPath QQuickContext2D::createTextGlyphs(qreal x, qreal y, const QString& text)
{
    const QFontMetrics metrics(state.font);
    int yoffset = baseLineOffset(static_cast<QQuickContext2D::TextBaseLineType>(state.textBaseline), metrics);
    int xoffset = textAlignOffset(static_cast<QQuickContext2D::TextAlignType>(state.textAlign), metrics, text);
 
    QPainterPath textPath;
 
    textPath.addText(x - xoffset, y - yoffset+metrics.ascent(), state.font, text);
    return textPath;
}
 
 
static inline bool areCollinear(const QPointF& a, const QPointF& b, const QPointF& c)
{
    // Solved from comparing the slopes of a to b and b to c: (ay-by)/(ax-bx) == (cy-by)/(cx-bx)
    return qFuzzyCompare((c.y() - b.y()) * (a.x() - b.x()), (a.y() - b.y()) * (c.x() - b.x()));
}
 
static inline bool withinRange(qreal p, qreal a, qreal b)
{
    return (p >= a && p <= b) || (p >= b && p <= a);
}
 
bool QQuickContext2D::isPointInPath(qreal x, qreal y) const
{
    if (!state.invertibleCTM)
        return false;
 
    if (!m_path.elementCount())
        return false;
 
    if (!qt_is_finite(x) || !qt_is_finite(y))
        return false;
 
    QPointF point(x, y);
    QTransform ctm = state.matrix;
    QPointF p = ctm.inverted().map(point);
    if (!qt_is_finite(p.x()) || !qt_is_finite(p.y()))
        return false;
 
    const_cast<QQuickContext2D *>(this)->m_path.setFillRule(state.fillRule);
 
    bool contains = m_path.contains(p);
 
    if (!contains) {
        // check whether the point is on the border
        QPolygonF border = m_path.toFillPolygon();
 
        QPointF p1 = border.at(0);
        QPointF p2;
 
        for (int i = 1; i < border.size(); ++i) {
            p2 = border.at(i);
            if (areCollinear(p, p1, p2)
                    // Once we know that the points are collinear we
                    // only need to check one of the coordinates
                    && (qAbs(p2.x() - p1.x()) > qAbs(p2.y() - p1.y()) ?
                        withinRange(p.x(), p1.x(), p2.x()) :
                        withinRange(p.y(), p1.y(), p2.y()))) {
                return true;
            }
            p1 = p2;
        }
    }
    return contains;
}
 
QMutex QQuickContext2D::mutex;
 
QQuickContext2D::QQuickContext2D(QObject *parent)
    : QQuickCanvasContext(parent)
    , m_buffer(new QQuickContext2DCommandBuffer)
    , m_v4engine(nullptr)
    , m_surface(nullptr)
    , m_thread(nullptr)
    , m_grabbed(false)
{
}
 
QQuickContext2D::~QQuickContext2D()
{
    mutex.lock();
    m_texture->setItem(nullptr);
    delete m_buffer;
    m_texture->deleteLater();
 
    mutex.unlock();
}
 
QV4::ReturnedValue QQuickContext2D::v4value() const
{
    return m_v4value.value();
}
 
QStringList QQuickContext2D::contextNames() const
{
    return QStringList() << QStringLiteral("2d");
}
 
void QQuickContext2D::init(QQuickCanvasItem *canvasItem, const QVariantMap &args)
{
    Q_UNUSED(args);
 
    m_canvas = canvasItem;
    m_renderTarget = canvasItem->renderTarget();
    m_renderStrategy = canvasItem->renderStrategy();
 
    // Disable threaded background rendering if the platform has issues with it
    if (m_renderTarget == QQuickCanvasItem::FramebufferObject
            && m_renderStrategy == QQuickCanvasItem::Threaded
            && !QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedOpenGL)) {
        m_renderTarget = QQuickCanvasItem::Image;
    }
 
    // Disable framebuffer object based rendering always in Qt 6. It
    // is not implemented in the new RHI-based graphics stack, but the
    // enum value is still present. Switch to Image instead.
    if (m_renderTarget == QQuickCanvasItem::FramebufferObject)
        m_renderTarget = QQuickCanvasItem::Image;
 
    m_texture = new QQuickContext2DImageTexture;
 
    m_texture->setItem(canvasItem);
    m_texture->setCanvasWindow(canvasItem->canvasWindow().toRect());
    m_texture->setTileSize(canvasItem->tileSize());
    m_texture->setCanvasSize(canvasItem->canvasSize().toSize());
    m_texture->setSmooth(canvasItem->smooth());
    m_texture->setAntialiasing(canvasItem->antialiasing());
    m_texture->setOnCustomThread(m_renderStrategy == QQuickCanvasItem::Threaded);
    m_thread = QThread::currentThread();
 
    QThread *renderThread = m_thread;
    if (m_renderStrategy == QQuickCanvasItem::Threaded)
        renderThread = QQuickContext2DRenderThread::instance(qmlEngine(canvasItem));
    if (renderThread && renderThread != QThread::currentThread())
        m_texture->moveToThread(renderThread);
    connect(m_texture, SIGNAL(textureChanged()), SIGNAL(textureChanged()));
 
    reset();
}
 
void QQuickContext2D::prepare(const QSize& canvasSize, const QSize& tileSize, const QRect& canvasWindow, const QRect& dirtyRect, bool smooth, bool antialiasing)
{
    if (m_texture->thread() == QThread::currentThread()) {
        m_texture->canvasChanged(canvasSize, tileSize, canvasWindow, dirtyRect, smooth, antialiasing);
    } else {
        QEvent *e =  new QQuickContext2DTexture::CanvasChangeEvent(canvasSize,
                                                                   tileSize,
                                                                   canvasWindow,
                                                                   dirtyRect,
                                                                   smooth,
                                                                   antialiasing);
        QCoreApplication::postEvent(m_texture, e);
    }
}
 
void QQuickContext2D::flush()
{
    if (m_buffer) {
        if (m_texture->thread() == QThread::currentThread())
            m_texture->paint(m_buffer);
        else
            QCoreApplication::postEvent(m_texture, new QQuickContext2DTexture::PaintEvent(m_buffer));
    }
    m_buffer = new QQuickContext2DCommandBuffer();
}
 
QQuickContext2DTexture *QQuickContext2D::texture() const
{
    return m_texture;
}
 
QImage QQuickContext2D::toImage(const QRectF& bounds)
{
    if (m_texture->thread() == QThread::currentThread()) {
            flush();
            m_texture->grabImage(bounds);
    } else if (m_renderStrategy == QQuickCanvasItem::Cooperative) {
        qWarning() << "Pixel readback is not supported in Cooperative mode, please try Threaded or Immediate mode";
        return QImage();
    } else {
        flush();
        QCoreApplication::postEvent(m_texture, new QEvent(QEvent::Type(QEvent::User + 10)));
        QMetaObject::invokeMethod(m_texture,
                                  "grabImage",
                                  Qt::BlockingQueuedConnection,
                                  Q_ARG(QRectF, bounds));
    }
    QImage img = m_grabbedImage;
    m_grabbedImage = QImage();
    m_grabbed = false;
    return img;
}
 
 
QQuickContext2DEngineData::QQuickContext2DEngineData(QV4::ExecutionEngine *v4)
{
    QV4::Scope scope(v4);
 
    QV4::ScopedObject proto(scope, QQuickJSContext2DPrototype::create(v4));
    proto->defineAccessorProperty(QStringLiteral("strokeStyle"), QQuickJSContext2D::method_get_strokeStyle, QQuickJSContext2D::method_set_strokeStyle);
    proto->defineAccessorProperty(QStringLiteral("font"), QQuickJSContext2D::method_get_font, QQuickJSContext2D::method_set_font);
    proto->defineAccessorProperty(QStringLiteral("fillRule"), QQuickJSContext2D::method_get_fillRule, QQuickJSContext2D::method_set_fillRule);
    proto->defineAccessorProperty(QStringLiteral("globalAlpha"), QQuickJSContext2D::method_get_globalAlpha, QQuickJSContext2D::method_set_globalAlpha);
    proto->defineAccessorProperty(QStringLiteral("lineCap"), QQuickJSContext2D::method_get_lineCap, QQuickJSContext2D::method_set_lineCap);
    proto->defineAccessorProperty(QStringLiteral("shadowOffsetX"), QQuickJSContext2D::method_get_shadowOffsetX, QQuickJSContext2D::method_set_shadowOffsetX);
    proto->defineAccessorProperty(QStringLiteral("shadowOffsetY"), QQuickJSContext2D::method_get_shadowOffsetY, QQuickJSContext2D::method_set_shadowOffsetY);
    proto->defineAccessorProperty(QStringLiteral("globalCompositeOperation"), QQuickJSContext2D::method_get_globalCompositeOperation, QQuickJSContext2D::method_set_globalCompositeOperation);
    proto->defineAccessorProperty(QStringLiteral("miterLimit"), QQuickJSContext2D::method_get_miterLimit, QQuickJSContext2D::method_set_miterLimit);
    proto->defineAccessorProperty(QStringLiteral("fillStyle"), QQuickJSContext2D::method_get_fillStyle, QQuickJSContext2D::method_set_fillStyle);
    proto->defineAccessorProperty(QStringLiteral("shadowColor"), QQuickJSContext2D::method_get_shadowColor, QQuickJSContext2D::method_set_shadowColor);
    proto->defineAccessorProperty(QStringLiteral("textBaseline"), QQuickJSContext2D::method_get_textBaseline, QQuickJSContext2D::method_set_textBaseline);
#if QT_CONFIG(quick_path)
    proto->defineAccessorProperty(QStringLiteral("path"), QQuickJSContext2D::method_get_path, QQuickJSContext2D::method_set_path);
#endif
    proto->defineAccessorProperty(QStringLiteral("lineJoin"), QQuickJSContext2D::method_get_lineJoin, QQuickJSContext2D::method_set_lineJoin);
    proto->defineAccessorProperty(QStringLiteral("lineWidth"), QQuickJSContext2D::method_get_lineWidth, QQuickJSContext2D::method_set_lineWidth);
    proto->defineAccessorProperty(QStringLiteral("textAlign"), QQuickJSContext2D::method_get_textAlign, QQuickJSContext2D::method_set_textAlign);
    proto->defineAccessorProperty(QStringLiteral("shadowBlur"), QQuickJSContext2D::method_get_shadowBlur, QQuickJSContext2D::method_set_shadowBlur);
    proto->defineAccessorProperty(QStringLiteral("lineDashOffset"), QQuickJSContext2D::method_get_lineDashOffset, QQuickJSContext2D::method_set_lineDashOffset);
    contextPrototype = proto;
 
    proto = scope.engine->newObject();
    proto->defineDefaultProperty(QStringLiteral("addColorStop"), QQuickContext2DStyle::gradient_proto_addColorStop, 0);
    gradientProto = proto;
 
    proto = scope.engine->newObject();
    proto->defineAccessorProperty(scope.engine->id_length(), QQuickJSContext2DPixelData::proto_get_length, nullptr);
    pixelArrayProto = proto;
}
 
QQuickContext2DEngineData::~QQuickContext2DEngineData()
{
}
 
void QQuickContext2D::popState()
{
    if (m_stateStack.isEmpty())
        return;
 
    QQuickContext2D::State newState = m_stateStack.pop();
 
    if (state.matrix != newState.matrix)
        buffer()->updateMatrix(newState.matrix);
 
    if (newState.globalAlpha != state.globalAlpha)
        buffer()->setGlobalAlpha(newState.globalAlpha);
 
    if (newState.globalCompositeOperation != state.globalCompositeOperation)
        buffer()->setGlobalCompositeOperation(newState.globalCompositeOperation);
 
    if (newState.fillStyle != state.fillStyle)
        buffer()->setFillStyle(newState.fillStyle);
 
    if (newState.strokeStyle != state.strokeStyle)
        buffer()->setStrokeStyle(newState.strokeStyle);
 
    if (newState.lineWidth != state.lineWidth)
        buffer()->setLineWidth(newState.lineWidth);
 
    if (newState.lineCap != state.lineCap)
        buffer()->setLineCap(newState.lineCap);
 
    if (newState.lineJoin != state.lineJoin)
        buffer()->setLineJoin(newState.lineJoin);
 
    if (newState.miterLimit != state.miterLimit)
        buffer()->setMiterLimit(newState.miterLimit);
 
    if (newState.clip != state.clip || newState.clipPath != state.clipPath)
        buffer()->clip(newState.clip, newState.clipPath);
 
    if (newState.shadowBlur != state.shadowBlur)
        buffer()->setShadowBlur(newState.shadowBlur);
 
    if (newState.shadowColor != state.shadowColor)
        buffer()->setShadowColor(newState.shadowColor);
 
    if (newState.shadowOffsetX != state.shadowOffsetX)
        buffer()->setShadowOffsetX(newState.shadowOffsetX);
 
    if (newState.shadowOffsetY != state.shadowOffsetY)
        buffer()->setShadowOffsetY(newState.shadowOffsetY);
 
    if (newState.lineDash != state.lineDash)
        buffer()->setLineDash(newState.lineDash);
 
    m_path = state.matrix.map(m_path);
    state = newState;
    m_path = state.matrix.inverted().map(m_path);
}
void QQuickContext2D::pushState()
{
    m_stateStack.push(state);
}
 
void QQuickContext2D::reset()
{
    QQuickContext2D::State newState;
 
    m_path = QPainterPath();
 
    newState.clipPath.setFillRule(Qt::WindingFill);
 
    m_stateStack.clear();
    m_stateStack.push(newState);
    popState();
    m_buffer->clearRect(QRectF(0, 0, m_canvas->width(), m_canvas->height()));
}
 
QV4::ExecutionEngine *QQuickContext2D::v4Engine() const
{
    return m_v4engine;
}
 
void QQuickContext2D::setV4Engine(QV4::ExecutionEngine *engine)
{
    if (m_v4engine != engine) {
        m_v4engine = engine;
 
        if (m_v4engine == nullptr)
            return;
 
        QQuickContext2DEngineData *ed = engineData(engine);
        QV4::Scope scope(engine);
        QV4::Scoped<QQuickJSContext2D> wrapper(scope, engine->memoryManager->allocate<QQuickJSContext2D>());
        QV4::ScopedObject p(scope, ed->contextPrototype.value());
        wrapper->setPrototypeOf(p);
        wrapper->d()->setContext(this);
        m_v4value = wrapper;
    }
}
 
QT_END_NAMESPACE
 
#include "moc_qquickcontext2d_p.cpp"