--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsgcontext2d_p.h"
+#include "qsgcontext2d_p_p.h"
+#include "private/qsgadaptationlayer_p.h"
+#include "qsgcanvasitem_p.h"
+#include <QtOpenGL/qglframebufferobject.h>
+#include <QtCore/qdebug.h>
+#include "private/qsgcontext_p.h"
+
+#include <QtGui/qgraphicsitem.h>
+#include <QtGui/qapplication.h>
+#include <QtGui/qgraphicseffect.h>
+#include <qdeclarativeinfo.h>
+#include <QtCore/qmath.h>
+#include "qdeclarativepixmapcache_p.h"
+#include <QtScript/QScriptEngine>
+
+QT_BEGIN_NAMESPACE
+
+static const double Q_PI = 3.14159265358979323846; // pi
+template <class T>
+void memcpy_vector(QVector<T>* dst, const QVector<T>& src)
+{
+ int pos = dst->size();
+ dst->resize(pos + src.size());
+ memmove(dst->data() + pos, src.constData(), sizeof(T) * src.size());
+}
+
+template <class T>
+void copy_vector(QVector<T>* dst, const QVector<T>& src)
+{
+ int pos = dst->size();
+ dst->resize(pos + src.size());
+ for (int i = 0; i < src.size(); i++) {
+ (*dst)[pos + i] = src[i];
+ }
+}
+
+// Note, this is exported but in a private header as qtopengl depends on it.
+// But it really should be considered private API
+void qt_blurImage(QPainter *p, QImage &blurImage, qreal radius, bool quality, bool alphaOnly, int transposed = 0);
+void qt_blurImage(QImage &blurImage, qreal radius, bool quality, int transposed = 0);
+
+#define DEGREES(t) ((t) * 180.0 / Q_PI)
+#define qClamp(val, min, max) qMin(qMax(val, min), max)
+
+static inline int extractInt(const char **name)
+{
+ int result = 0;
+ bool negative = false;
+
+ //eat leading whitespace
+ while (isspace(*name[0]))
+ ++*name;
+
+ if (*name[0] == '-') {
+ ++*name;
+ negative = true;
+ } /*else if (name[0] == '+')
+ ++name; //ignore*/
+
+ //construct number
+ while (isdigit(*name[0])) {
+ result = result * 10 + (*name[0] - '0');
+ ++*name;
+ }
+ if (negative)
+ result = -result;
+
+ //handle optional percentage
+ if (*name[0] == '%')
+ result *= qreal(255)/100; //### floor or round?
+
+ //eat trailing whitespace
+ while (isspace(*name[0]))
+ ++*name;
+
+ return result;
+}
+
+static bool qt_get_rgb(const QString &string, QRgb *rgb)
+{
+ const char *name = string.toLatin1().constData();
+ int len = qstrlen(name);
+
+ if (len < 5)
+ return false;
+
+ bool handleAlpha = false;
+
+ if (name[0] != 'r')
+ return false;
+ if (name[1] != 'g')
+ return false;
+ if (name[2] != 'b')
+ return false;
+ if (name[3] == 'a') {
+ handleAlpha = true;
+ if(name[3] != '(')
+ return false;
+ } else if (name[3] != '(')
+ return false;
+
+ name += 4;
+
+ int r, g, b, a = 1;
+ int result;
+
+ //red
+ result = extractInt(&name);
+ if (name[0] == ',') {
+ r = result;
+ ++name;
+ } else
+ return false;
+
+ //green
+ result = extractInt(&name);
+ if (name[0] == ',') {
+ g = result;
+ ++name;
+ } else
+ return false;
+
+ char nextChar = handleAlpha ? ',' : ')';
+
+ //blue
+ result = extractInt(&name);
+ if (name[0] == nextChar) {
+ b = result;
+ ++name;
+ } else
+ return false;
+
+ //alpha
+ if (handleAlpha) {
+ result = extractInt(&name);
+ if (name[0] == ')') {
+ a = result * 255; //map 0-1 to 0-255
+ ++name;
+ } else
+ return false;
+ }
+
+ if (name[0] != '\0')
+ return false;
+
+ *rgb = qRgba(qClamp(r,0,255), qClamp(g,0,255), qClamp(b,0,255), qClamp(a,0,255));
+ return true;
+}
+
+//### unify with qt_get_rgb?
+static bool qt_get_hsl(const QString &string, QColor *color)
+{
+ const char *name = string.toLatin1().constData();
+ int len = qstrlen(name);
+
+ if (len < 5)
+ return false;
+
+ bool handleAlpha = false;
+
+ if (name[0] != 'h')
+ return false;
+ if (name[1] != 's')
+ return false;
+ if (name[2] != 'l')
+ return false;
+ if (name[3] == 'a') {
+ handleAlpha = true;
+ if(name[3] != '(')
+ return false;
+ } else if (name[3] != '(')
+ return false;
+
+ name += 4;
+
+ int h, s, l, a = 1;
+ int result;
+
+ //hue
+ result = extractInt(&name);
+ if (name[0] == ',') {
+ h = result;
+ ++name;
+ } else
+ return false;
+
+ //saturation
+ result = extractInt(&name);
+ if (name[0] == ',') {
+ s = result;
+ ++name;
+ } else
+ return false;
+
+ char nextChar = handleAlpha ? ',' : ')';
+
+ //lightness
+ result = extractInt(&name);
+ if (name[0] == nextChar) {
+ l = result;
+ ++name;
+ } else
+ return false;
+
+ //alpha
+ if (handleAlpha) {
+ result = extractInt(&name);
+ if (name[0] == ')') {
+ a = result * 255; //map 0-1 to 0-255
+ ++name;
+ } else
+ return false;
+ }
+
+ if (name[0] != '\0')
+ return false;
+
+ *color = QColor::fromHsl(qClamp(h,0,255), qClamp(s,0,255), qClamp(l,0,255), qClamp(a,0,255));
+ return true;
+}
+
+//### optimize further
+QColor colorFromString(const QString &name)
+{
+ if (name.startsWith(QLatin1String("rgb"))) {
+ QRgb rgb;
+ if (qt_get_rgb(name, &rgb))
+ return QColor(rgb);
+ } else if (name.startsWith(QLatin1String("hsl"))) {
+ QColor color;
+ if (qt_get_hsl(name, &color))
+ return color;
+ }
+
+ return QColor(name);
+}
+
+
+static QPainter::CompositionMode compositeOperatorFromString(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("darker")) {
+ return QPainter::CompositionMode_SourceOver;
+ } else if (compositeOperator == QLatin1String("lighter")) {
+ return QPainter::CompositionMode_SourceOver;
+ } else if (compositeOperator == QLatin1String("copy")) {
+ return QPainter::CompositionMode_Source;
+ } else if (compositeOperator == QLatin1String("xor")) {
+ return QPainter::CompositionMode_Xor;
+ }
+
+ return QPainter::CompositionMode_SourceOver;
+}
+
+static QString compositeOperatorToString(QPainter::CompositionMode op)
+{
+ switch (op) {
+ case QPainter::CompositionMode_SourceOver:
+ return QLatin1String("source-over");
+ case QPainter::CompositionMode_DestinationOver:
+ return QLatin1String("destination-over");
+ case QPainter::CompositionMode_Clear:
+ return QLatin1String("clear");
+ case QPainter::CompositionMode_Source:
+ return QLatin1String("source");
+ case QPainter::CompositionMode_Destination:
+ return QLatin1String("destination");
+ case QPainter::CompositionMode_SourceIn:
+ return QLatin1String("source-in");
+ case QPainter::CompositionMode_DestinationIn:
+ return QLatin1String("destination-in");
+ case QPainter::CompositionMode_SourceOut:
+ return QLatin1String("source-out");
+ case QPainter::CompositionMode_DestinationOut:
+ return QLatin1String("destination-out");
+ case QPainter::CompositionMode_SourceAtop:
+ return QLatin1String("source-atop");
+ case QPainter::CompositionMode_DestinationAtop:
+ return QLatin1String("destination-atop");
+ case QPainter::CompositionMode_Xor:
+ return QLatin1String("xor");
+ case QPainter::CompositionMode_Plus:
+ return QLatin1String("plus");
+ case QPainter::CompositionMode_Multiply:
+ return QLatin1String("multiply");
+ case QPainter::CompositionMode_Screen:
+ return QLatin1String("screen");
+ case QPainter::CompositionMode_Overlay:
+ return QLatin1String("overlay");
+ case QPainter::CompositionMode_Darken:
+ return QLatin1String("darken");
+ case QPainter::CompositionMode_Lighten:
+ return QLatin1String("lighten");
+ case QPainter::CompositionMode_ColorDodge:
+ return QLatin1String("color-dodge");
+ case QPainter::CompositionMode_ColorBurn:
+ return QLatin1String("color-burn");
+ case QPainter::CompositionMode_HardLight:
+ return QLatin1String("hard-light");
+ case QPainter::CompositionMode_SoftLight:
+ return QLatin1String("soft-light");
+ case QPainter::CompositionMode_Difference:
+ return QLatin1String("difference");
+ case QPainter::CompositionMode_Exclusion:
+ return QLatin1String("exclusion");
+ default:
+ break;
+ }
+ return QString();
+}
+
+bool QSGContext2DPrivate::hasShadow() const
+{
+ return state.shadowColor.isValid()
+ && state.shadowColor.alpha()
+ && (state.shadowBlur || state.shadowOffsetX || state.shadowOffsetY);
+}
+
+void QSGContext2DPrivate::clearShadow()
+{
+ state.shadowOffsetX = 0;
+ state.shadowOffsetY = 0;
+ state.shadowBlur = 0;
+ state.shadowColor = QColor();
+}
+
+QImage QSGContext2DPrivate::makeShadowImage(const QPixmap& pix)
+{
+ QImage shadowImg(pix.width() + state.shadowBlur * 2 + qAbs(state.shadowOffsetX),
+ pix.height() + state.shadowBlur *2 + qAbs(state.shadowOffsetY),
+ QImage::Format_ARGB32);
+ shadowImg.fill(0);
+ QPainter tmpPainter(&shadowImg);
+ tmpPainter.setCompositionMode(QPainter::CompositionMode_Source);
+ qreal shadowX = state.shadowOffsetX > 0? state.shadowOffsetX : 0;
+ qreal shadowY = state.shadowOffsetY > 0? state.shadowOffsetY : 0;
+
+ tmpPainter.drawPixmap(shadowX, shadowY, pix);
+ tmpPainter.end();
+
+ // blur the alpha channel
+ if (state.shadowBlur > 0) {
+ QImage blurred(shadowImg.size(), QImage::Format_ARGB32);
+ blurred.fill(0);
+ QPainter blurPainter(&blurred);
+ qt_blurImage(&blurPainter, shadowImg, state.shadowBlur, false, true);
+ blurPainter.end();
+ shadowImg = blurred;
+ }
+
+ // blacken the image with shadow color...
+ tmpPainter.begin(&shadowImg);
+ tmpPainter.setCompositionMode(QPainter::CompositionMode_SourceIn);
+ tmpPainter.fillRect(shadowImg.rect(), state.shadowColor);
+ tmpPainter.end();
+ return shadowImg;
+}
+
+void QSGContext2DPrivate::fillRectShadow(QPainter* p, QRectF shadowRect)
+{
+ QRectF r = shadowRect;
+ r.moveTo(0, 0);
+
+ QImage shadowImage(r.size().width() + 1, r.size().height() + 1, QImage::Format_ARGB32);
+ QPainter tp;
+ tp.begin(&shadowImage);
+ tp.fillRect(r, p->brush());
+ tp.end();
+ shadowImage = makeShadowImage(QPixmap::fromImage(shadowImage));
+
+ qreal dx = shadowRect.left() + (state.shadowOffsetX < 0? state.shadowOffsetX:0);
+ qreal dy = shadowRect.top() + (state.shadowOffsetY < 0? state.shadowOffsetY:0);
+
+ p->drawImage(dx, dy, shadowImage);
+ p->fillRect(shadowRect, p->brush());
+}
+
+void QSGContext2DPrivate::fillShadowPath(QPainter* p, const QPainterPath& path)
+{
+ QRectF r = path.boundingRect();
+ QImage img(r.size().width() + r.left() + 1,
+ r.size().height() + r.top() + 1,
+ QImage::Format_ARGB32);
+ img.fill(0);
+ QPainter tp(&img);
+ tp.fillPath(path.translated(0, 0), p->brush());
+ tp.end();
+
+ QImage shadowImage = makeShadowImage(QPixmap::fromImage(img));
+ qreal dx = r.left() + (state.shadowOffsetX < 0? state.shadowOffsetX:0);
+ qreal dy = r.top() + (state.shadowOffsetY < 0? state.shadowOffsetY:0);
+
+ p->drawImage(dx, dy, shadowImage);
+ p->fillPath(path, p->brush());
+}
+
+void QSGContext2DPrivate::strokeShadowPath(QPainter* p, const QPainterPath& path)
+{
+ QRectF r = path.boundingRect();
+ QImage img(r.size().width() + r.left() + 1,
+ r.size().height() + r.top() + 1,
+ QImage::Format_ARGB32);
+ img.fill(0);
+ QPainter tp(&img);
+ tp.strokePath(path, p->pen());
+ tp.end();
+
+ QImage shadowImage = makeShadowImage(QPixmap::fromImage(img));
+ qreal dx = r.left() + (state.shadowOffsetX < 0? state.shadowOffsetX:0);
+ qreal dy = r.top() + (state.shadowOffsetY < 0? state.shadowOffsetY:0);
+ p->drawImage(dx, dy, shadowImage);
+ p->strokePath(path, p->pen());
+}
+
+void QSGContext2DPrivate::clear()
+{
+ clearRect(0, 0, size.width(), size.height());
+}
+
+void QSGContext2DPrivate::reset()
+{
+ stateStack.clear();
+ state.matrix = QMatrix();
+ state.clipPath = QPainterPath();
+ state.strokeStyle = Qt::black;
+ state.fillStyle = Qt::black;
+ state.globalAlpha = 1.0;
+ state.lineWidth = 1;
+ state.lineCap = Qt::FlatCap;
+ state.lineJoin = Qt::MiterJoin;
+ state.miterLimit = 10;
+ state.shadowOffsetX = 0;
+ state.shadowOffsetY = 0;
+ state.shadowBlur = 0;
+ state.shadowColor = qRgba(0, 0, 0, 0);
+ state.globalCompositeOperation = QPainter::CompositionMode_SourceOver;
+ state.font = QFont();
+ state.textAlign = QSGContext2D::Start;
+ state.textBaseline = QSGContext2D::Alphabetic;
+ clear();
+}
+
+
+void QSGContext2DPrivate::updateMatrix(const QMatrix& m)
+{
+ commands.push_back(QSGContext2D::UpdateMatrix);
+ matrixes.push_back(m);
+}
+
+
+
+
+void QSGContext2DPrivate::save()
+{
+ stateStack.push(state);
+}
+
+void QSGContext2DPrivate::restore()
+{
+ if (!stateStack.isEmpty()) {
+ bool update = false;
+ QSGContext2D::State s = stateStack.pop();
+ if (state.matrix != s.matrix) {
+ updateMatrix(s.matrix);
+ update = true;
+ }
+
+ if (s.pen != state.pen) {
+ commands.push_back(QSGContext2D::UpdatePen);
+ pens.push_back(s.pen);
+ update = true;
+ }
+
+ if (s.globalAlpha != state.globalAlpha) {
+ commands.push_back(QSGContext2D::GlobalAlpha);
+ reals.push_back(s.globalAlpha);
+ update = true;
+ }
+
+ if (s.globalCompositeOperation != state.globalCompositeOperation) {
+ commands.push_back(QSGContext2D::GlobalCompositeOperation);
+ ints.push_back(s.globalCompositeOperation);
+ update = true;
+ }
+
+ if (s.font != state.font) {
+ commands.push_back(QSGContext2D::Font);
+ fonts.push_back(s.font);
+ update = true;
+ }
+
+ if (s.fillStyle != state.fillStyle) {
+ commands.push_back(QSGContext2D::FillStyle);
+ brushes.push_back(s.fillStyle);
+ update = true;
+ }
+
+ if (s.clipPath != state.clipPath) {
+ //commands.push_back(QSGContext2D::ClipPath);
+ update = true;
+ }
+
+ if (s.textAlign != state.textAlign) {
+ commands.push_back(QSGContext2D::TextAlign);
+ update = true;
+ }
+
+ if (s.textBaseline != state.textBaseline) {
+ commands.push_back(QSGContext2D::TextBaseline);
+ update = true;
+ }
+
+ if (s.shadowBlur != state.shadowBlur
+ || s.shadowColor != state.shadowColor
+ || s.shadowOffsetX != state.shadowOffsetX
+ || s.shadowOffsetY != state.shadowOffsetY) {
+ update = true;
+ }
+
+ if (update)
+ state = s;
+ }
+}
+
+void QSGContext2DPrivate::scale(qreal x, qreal y)
+{
+ state.matrix.scale(x, y);
+ updateMatrix(state.matrix);
+}
+
+void QSGContext2DPrivate::rotate(qreal angle)
+{
+ state.matrix.rotate(DEGREES(angle));
+ updateMatrix(state.matrix);
+}
+
+
+void QSGContext2DPrivate::translate(qreal x, qreal y)
+{
+ state.matrix.translate(x, y);
+ updateMatrix(state.matrix);
+}
+
+void QSGContext2DPrivate::transform(
+ qreal m11, qreal m12,
+ qreal m21, qreal m22,
+ qreal dx, qreal dy)
+{
+ QMatrix matrix(m11, m12, m21, m22, dx, dy);
+ state.matrix *= matrix;
+ updateMatrix(state.matrix);
+}
+
+void QSGContext2DPrivate::setTransform(
+ qreal m11, qreal m12,
+ qreal m21, qreal m22,
+ qreal dx, qreal dy)
+{
+ QMatrix matrix(m11, m12, m21, m22, dx, dy);
+ state.matrix = matrix;
+ updateMatrix(state.matrix);
+}
+
+void QSGContext2DPrivate::clearRect(qreal x, qreal y,
+ qreal w, qreal h)
+{
+ commands.push_back(QSGContext2D::ClearRect);
+ reals.push_back(x);
+ reals.push_back(y);
+ reals.push_back(w);
+ reals.push_back(h);
+}
+
+void QSGContext2DPrivate::fillRect(qreal x, qreal y,
+ qreal w, qreal h)
+{
+ commands.push_back(QSGContext2D::FillRect);
+ reals.push_back(x);
+ reals.push_back(y);
+ reals.push_back(w);
+ reals.push_back(h);
+}
+
+void QSGContext2DPrivate::strokeRect(qreal x, qreal y,
+ qreal w, qreal h)
+{
+ QPainterPath path;
+ path.addRect(x, y, w, h);
+ commands.push_back(QSGContext2D::Stroke);
+ pathes.push_back(path);
+}
+
+void QSGContext2DPrivate::beginPath()
+{
+ path = QPainterPath();
+}
+
+void QSGContext2DPrivate::closePath()
+{
+ path.closeSubpath();
+}
+
+void QSGContext2DPrivate::moveTo( qreal x, qreal y)
+{
+ path.moveTo(state.matrix.map(QPointF(x, y)));
+}
+
+void QSGContext2DPrivate::lineTo( qreal x, qreal y)
+{
+ path.lineTo(state.matrix.map(QPointF(x, y)));
+}
+
+void QSGContext2DPrivate::quadraticCurveTo(qreal cpx, qreal cpy,
+ qreal x, qreal y)
+{
+ path.quadTo(state.matrix.map(QPointF(cpx, cpy)),
+ state.matrix.map(QPointF(x, y)));
+}
+
+void QSGContext2DPrivate::bezierCurveTo(qreal cp1x, qreal cp1y,
+ qreal cp2x, qreal cp2y,
+ qreal x, qreal y)
+{
+ path.cubicTo(state.matrix.map(QPointF(cp1x, cp1y)),
+ state.matrix.map(QPointF(cp2x, cp2y)),
+ state.matrix.map(QPointF(x, y)));
+}
+
+void QSGContext2DPrivate::arcTo(qreal x1, qreal y1,
+ qreal x2, qreal y2,
+ qreal radius)
+{
+ QPointF st = state.matrix.map(QPoint(x1, y1));
+ QPointF end = state.matrix.map(QPoint(x2, y2));
+
+ path.arcTo(st.x(), st.y(),
+ end.x()-st.x(), end.y()-st.y(),
+ radius, 90);
+}
+
+void QSGContext2DPrivate::rect(qreal x, qreal y,
+ qreal w, qreal h)
+{
+ QPainterPath path;
+ path.addRect(QRectF(x, y, w, h));
+ path.addPath(state.matrix.map(path));
+}
+
+void QSGContext2DPrivate::arc(qreal xc,
+ qreal yc,
+ qreal radius,
+ qreal sar,
+ qreal ear,
+ bool antiClockWise)
+{
+ QPainterPath path;
+
+ //### 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 = DEGREES(sar);
+ float ea = DEGREES(ear);
+
+ double span = 0;
+
+ double xs = xc - radius;
+ double ys = yc - radius;
+ double width = radius*2;
+ double height = radius*2;
+
+ 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;
+ }
+
+ path.moveTo(QPointF(xc + radius * qCos(sar),
+ yc - radius * qSin(sar)));
+
+ path.arcTo(xs, ys, width, height, sa, span);
+
+ path.addPath(state.matrix.map(path));
+}
+
+void QSGContext2DPrivate::fill()
+{
+ commands.push_back(QSGContext2D::Fill);
+ pathes.push_back(path);
+}
+
+void QSGContext2DPrivate::stroke()
+{
+ commands.push_back(QSGContext2D::Stroke);
+ pathes.push_back(path);
+// painter->setMatrix(state.matrix, false);
+// QPainterPath tmp = state.matrix.inverted().map(path); //why?
+// painter->strokePath(tmp, painter->pen());
+}
+
+void QSGContext2DPrivate::clip()
+{
+ state.clipPath = path;
+ pathes.push_back(state.clipPath);
+ commands.push_back(QSGContext2D::Clip);
+}
+
+void QSGContext2DPrivate::setGlobalAlpha( qreal alpha)
+{
+ state.globalAlpha = alpha;
+ commands.push_back(QSGContext2D::GlobalAlpha);
+ reals.push_back(state.globalAlpha);
+}
+
+void QSGContext2DPrivate::setGlobalCompositeOperation( const QString &op)
+{
+ state.globalCompositeOperation = compositeOperatorFromString(op);
+ commands.push_back(QSGContext2D::GlobalCompositeOperation);
+ ints.push_back(state.globalCompositeOperation);
+}
+
+void QSGContext2DPrivate::setStrokeStyle( const QVariant &style)
+{
+ QSGCanvasGradient *gradient= qobject_cast<QSGCanvasGradient*>(style.value<QObject*>());
+ QBrush b;
+ if (gradient) {
+ b = gradient->value();
+ } else {
+ b = colorFromString(style.toString());
+ }
+
+ if (state.strokeStyle != b) {
+ state.strokeStyle = b;
+ state.pen.setBrush(state.strokeStyle);
+ commands.push_back(QSGContext2D::UpdatePen);
+ pens.push_back(state.pen);
+ }
+}
+void QSGContext2DPrivate::setStrokeColor(const QColor& color)
+{
+ if (state.strokeStyle != color) {
+ state.strokeStyle = color;
+ commands.push_back(QSGContext2D::UpdatePen);
+ QPen pen;
+ pen.setBrush(state.strokeStyle);
+ pens.push_back(pen);
+ }
+}
+
+void QSGContext2DPrivate::setFillColor(const QColor& color)
+{
+ if (state.fillStyle != color) {
+ state.fillStyle = color;
+ commands.push_back(QSGContext2D::UpdateBrush);
+ brushes.push_back(state.fillStyle);
+ }
+}
+
+void QSGContext2DPrivate::setFillStyle( const QVariant &style)
+{
+ QSGCanvasGradient *gradient= qobject_cast<QSGCanvasGradient*>(style.value<QObject*>());
+ QBrush b;
+ if (gradient) {
+ b = gradient->value();
+ } else {
+ b = colorFromString(style.toString());
+ }
+
+ if (state.fillStyle != b) {
+ state.fillStyle = b;
+ commands.push_back(QSGContext2D::UpdateBrush);
+ brushes.push_back(b);
+ }
+}
+
+
+void QSGContext2DPrivate::setLineWidth( qreal w)
+{
+ if (state.lineWidth != w) {
+ state.pen.setWidthF(w);
+ state.lineWidth = w;
+ commands.push_back(QSGContext2D::UpdatePen);
+ pens.push_back(state.pen);
+ }
+}
+
+void QSGContext2DPrivate::setLineCap( const QString& cap)
+{
+ Qt::PenCapStyle style;
+ if (cap == QLatin1String("round"))
+ style = Qt::RoundCap;
+ else if (cap == QLatin1String("square"))
+ style = Qt::SquareCap;
+ else //if (capString == "butt")
+ style = Qt::FlatCap;
+
+
+ if (state.lineCap != style) {
+ state.pen.setCapStyle(style);
+ state.lineCap = style;
+ commands.push_back(QSGContext2D::UpdatePen);
+ pens.push_back(state.pen);
+ }
+}
+
+void QSGContext2DPrivate::setLineJoin( const QString& join)
+{
+ Qt::PenJoinStyle style;
+ if (join == QLatin1String("round"))
+ style = Qt::RoundJoin;
+ else if (join == QLatin1String("bevel"))
+ style = Qt::BevelJoin;
+ else //if (joinString == "miter")
+ style = Qt::MiterJoin;
+ if (state.lineJoin != style) {
+ state.lineJoin = style;
+ state.pen.setJoinStyle(style);
+ commands.push_back(QSGContext2D::UpdatePen);
+ pens.push_back(state.pen);
+ }
+}
+
+void QSGContext2DPrivate::setMiterLimit( qreal limit)
+{
+ if (state.miterLimit != limit) {
+ state.pen.setMiterLimit(limit);
+ state.miterLimit = limit;
+ commands.push_back(QSGContext2D::UpdatePen);
+ pens.push_back(state.pen);
+ }
+}
+
+void QSGContext2DPrivate::setShadowOffsetX( qreal x)
+{
+ if (state.shadowOffsetX != x) {
+ state.shadowOffsetX = x;
+ commands.push_back(QSGContext2D::ShadowOffsetX);
+ reals.push_back(x);
+ }
+}
+
+void QSGContext2DPrivate::setShadowOffsetY( qreal y)
+{
+ if (state.shadowOffsetY != y) {
+ state.shadowOffsetY = y;
+ commands.push_back(QSGContext2D::ShadowOffsetY);
+ reals.push_back(y);
+ }
+}
+
+void QSGContext2DPrivate::setShadowBlur( qreal b)
+{
+ if (state.shadowBlur != b) {
+ state.shadowBlur = b;
+ commands.push_back(QSGContext2D::ShadowBlur);
+ reals.push_back(b);
+ }
+}
+
+void QSGContext2DPrivate::setShadowColor( const QString& color)
+{
+ QColor c = colorFromString(color);
+ if (state.shadowColor != c) {
+ state.shadowColor = c;
+ commands.push_back(QSGContext2D::ShadowColor);
+ colors.push_back(c);
+ }
+}
+
+void QSGContext2DPrivate::setFont( const QString& fontString)
+{
+ QFont font;
+ // ### this is simplified and incomplete
+ // ### TODO:get code from Qt webkit
+ QStringList tokens = fontString.split(QLatin1String(" "));
+ foreach (const QString &token, tokens) {
+ if (token == QLatin1String("italic"))
+ font.setItalic(true);
+ else if (token == QLatin1String("bold"))
+ font.setBold(true);
+ else if (token.endsWith(QLatin1String("px"))) {
+ QString number = token;
+ number.remove(QLatin1String("px"));
+ font.setPointSizeF(number.trimmed().toFloat());
+ } else
+ font.setFamily(token);
+ }
+
+ if (state.font != font) {
+ state.font = font;
+ commands.push_back(QSGContext2D::Font);
+ fonts.push_back(font);
+ }
+}
+
+void QSGContext2DPrivate::setTextBaseline( const QString& baseline)
+{
+ QSGContext2D::TextBaseLineType tbl;
+ if (baseline==QLatin1String("alphabetic"))
+ tbl = QSGContext2D::Alphabetic;
+ else if (baseline == QLatin1String("hanging"))
+ tbl = QSGContext2D::Hanging;
+ else if (baseline == QLatin1String("top"))
+ tbl = QSGContext2D::Top;
+ else if (baseline == QLatin1String("bottom"))
+ tbl = QSGContext2D::Bottom;
+ else if (baseline == QLatin1String("middle"))
+ tbl = QSGContext2D::Middle;
+ else {
+ tbl = QSGContext2D::Alphabetic;
+ Q_Q(QSGContext2D);
+ qmlInfo(q) << "QSGContext2D: invalid baseline:" << baseline;
+ }
+ if (state.textBaseline != tbl) {
+ state.textBaseline = tbl;
+ commands.push_back(QSGContext2D::TextBaseline);
+ ints.push_back(tbl);
+ }
+}
+
+void QSGContext2DPrivate::setTextAlign(const QString& align)
+{
+ QSGContext2D::TextAlignType ta;
+ if (align==QLatin1String("start"))
+ ta = QSGContext2D::Start;
+ else if (align == QLatin1String("end"))
+ ta = QSGContext2D::End;
+ else if (align == QLatin1String("left"))
+ ta = QSGContext2D::Left;
+ else if (align == QLatin1String("right"))
+ ta = QSGContext2D::Right;
+ else if (align == QLatin1String("center"))
+ ta = QSGContext2D::Center;
+ else {
+ ta = QSGContext2D::Start;
+ Q_Q(QSGContext2D);
+ qmlInfo(q) << "QSGContext2D: invalid text align:" << align;
+ }
+ if (state.textAlign != ta) {
+ state.textAlign = ta;
+ commands.push_back(QSGContext2D::TextAlign);
+ ints.push_back(ta);
+ }
+}
+
+void QSGContext2DPrivate::fillText(const QString& text, qreal x, qreal y)
+{
+ commands.push_back(QSGContext2D::FillText);
+ strings.push_back(text);
+ reals.push_back(x);
+ reals.push_back(y);
+ ints.push_back(state.textAlign);
+ ints.push_back(state.textBaseline);
+}
+
+
+void QSGContext2DPrivate::strokeText( const QString& text, qreal x, qreal y)
+{
+ commands.push_back(QSGContext2D::StrokeText);
+ strings.push_back(text);
+ reals.push_back(x);
+ reals.push_back(y);
+ ints.push_back(state.textAlign);
+ ints.push_back(state.textBaseline);
+}
+
+void QSGContext2DPrivate::drawImage(const QString& url, qreal dx, qreal dy)
+{
+ commands.push_back(QSGContext2D::DrawImage1);
+ strings.push_back(url);
+ reals.push_back(dx);
+ reals.push_back(dy);
+}
+
+void QSGContext2DPrivate::drawImage(const QString& url, qreal dx, qreal dy, qreal dw, qreal dh)
+{
+ commands.push_back(QSGContext2D::DrawImage2);
+ strings.push_back(url);
+ reals.push_back(dx);
+ reals.push_back(dy);
+ reals.push_back(dw);
+ reals.push_back(dh);
+}
+
+void QSGContext2DPrivate::drawImage(const QString& url, qreal sx, qreal sy, qreal sw, qreal sh, qreal dx, qreal dy, qreal dw, qreal dh)
+{
+ commands.push_back(QSGContext2D::DrawImage3);
+ strings.push_back(url);
+ reals.push_back(sx);
+ reals.push_back(sy);
+ reals.push_back(sw);
+ reals.push_back(sh);
+ reals.push_back(dx);
+ reals.push_back(dy);
+ reals.push_back(dw);
+ reals.push_back(dh);
+}
+
+QList<int> QSGContext2DPrivate::getImageData(qreal sx, qreal sy, qreal sw, qreal sh)
+{
+ Q_Q(QSGContext2D);
+ waitingForPainting = true;
+ commands.push_back(QSGContext2D::GetImageData);
+ reals.push_back(sx);
+ reals.push_back(sy);
+ reals.push_back(sw);
+ reals.push_back(sh);
+ q->sync();
+ return imageData;
+}
+
+void QSGContext2DPrivate::putImageData(const QVariantList& imageData, qreal dx, qreal dy, qreal w, qreal h)
+{
+ QImage image = cachedImage.copy(dx, dy, w, h);
+ uchar* data = image.bits();
+ int i = 0;
+ while(i< imageData.size() && i < image.byteCount()) {
+ //the stored order in QImage:BGRA
+ //the stored order in Canvas:RGBA
+ *(data+i) = imageData[i+2].toInt();//B
+ *(data+i+1) = imageData[i+1].toInt();//G
+ *(data+i+2) = imageData[i].toInt();//R
+ *(data+i+3) = imageData[i+3].toInt();//A
+ i+=4;
+ }
+ commands.push_back(QSGContext2D::PutImageData);
+ images.push_back(image);
+ reals.push_back(dx);
+ reals.push_back(dy);
+}
+
+void QSGContext2D::save()
+{
+ Q_D(QSGContext2D);
+ d->save();
+}
+
+
+void QSGContext2D::restore()
+{
+ Q_D(QSGContext2D);
+ d->restore();
+}
+
+
+void QSGContext2D::scale(qreal x, qreal y)
+{
+ Q_D(QSGContext2D);
+ d->scale(x, y);
+}
+
+
+void QSGContext2D::rotate(qreal angle)
+{
+ Q_D(QSGContext2D);
+ d->rotate(angle);
+}
+
+
+void QSGContext2D::translate(qreal x, qreal y)
+{
+ Q_D(QSGContext2D);
+ d->translate(x, y);
+}
+
+void QSGContext2D::transform(qreal m11, qreal m12, qreal m21, qreal m22,
+ qreal dx, qreal dy)
+{
+ Q_D(QSGContext2D);
+ d->transform(m11, m12, m21, m22, dx, dy);
+}
+
+
+void QSGContext2D::setTransform(qreal m11, qreal m12, qreal m21, qreal m22,
+ qreal dx, qreal dy)
+{
+ Q_D(QSGContext2D);
+ d->setTransform(m11, m12, m21, m22, dx, dy);
+}
+
+QString QSGContext2D::globalCompositeOperation() const
+{
+ Q_D(const QSGContext2D);
+ return compositeOperatorToString(d->state.globalCompositeOperation);
+}
+
+void QSGContext2D::setGlobalCompositeOperation(const QString &op)
+{
+ Q_D(QSGContext2D);
+ d->setGlobalCompositeOperation(op);
+}
+
+QVariant QSGContext2D::strokeStyle() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.strokeStyle;
+}
+
+void QSGContext2D::setStrokeStyle(const QVariant &style)
+{
+ Q_D(QSGContext2D);
+ d->setStrokeStyle(style);
+}
+
+QVariant QSGContext2D::fillStyle() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.fillStyle;
+}
+
+QColor QSGContext2D::strokeColor() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.strokeStyle.color();
+}
+
+QColor QSGContext2D::fillColor() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.fillStyle.color();
+}
+
+void QSGContext2D::setFillStyle(const QVariant &style)
+{
+ Q_D(QSGContext2D);
+ d->setFillStyle(style);
+}
+void QSGContext2D::setStrokeColor(const QColor& color)
+{
+ Q_D(QSGContext2D);
+ d->setStrokeColor(color);
+}
+
+void QSGContext2D::setFillColor(const QColor& color)
+{
+ Q_D(QSGContext2D);
+ d->setFillColor(color);
+}
+
+qreal QSGContext2D::globalAlpha() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.globalAlpha;
+}
+
+void QSGContext2D::setGlobalAlpha(qreal alpha)
+{
+ Q_D(QSGContext2D);
+ d->setGlobalAlpha(alpha);
+}
+
+QSGImage *QSGContext2D::createImage(const QString &url)
+{
+ Q_D(QSGContext2D);
+//### cache image
+ QSGImage* img = new QSGImage(d->canvas);
+ img->setSource(QUrl(url));
+ return img;
+}
+
+QSGCanvasGradient *QSGContext2D::createLinearGradient(qreal x0, qreal y0,
+ qreal x1, qreal y1)
+{
+ QLinearGradient g(x0, y0, x1, y1);
+ return new QSGCanvasGradient(g);
+}
+
+
+QSGCanvasGradient *QSGContext2D::createRadialGradient(qreal x0, qreal y0,
+ qreal r0, qreal x1,
+ qreal y1, qreal r1)
+{
+ QRadialGradient g(QPointF(x1, y1), r0+r1, QPointF(x0, y0));
+ return new QSGCanvasGradient(g);
+}
+
+qreal QSGContext2D::lineWidth() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.lineWidth;
+}
+
+void QSGContext2D::setLineWidth(qreal w)
+{
+ Q_D(QSGContext2D);
+ d->setLineWidth(w);
+}
+
+QString QSGContext2D::lineCap() const
+{
+ Q_D(const QSGContext2D);
+ switch(d->state.lineCap) {
+ case Qt::RoundCap:
+ return QLatin1String("round");
+ case Qt::FlatCap:
+ return QLatin1String("butt");
+ case Qt::SquareCap:
+ return QLatin1String("square");
+ default:
+ break;
+ }
+ return QLatin1String("");
+}
+
+void QSGContext2D::setLineCap(const QString &capString)
+{
+ Q_D(QSGContext2D);
+ d->setLineCap(capString);
+}
+
+QString QSGContext2D::lineJoin() const
+{
+ Q_D(const QSGContext2D);
+ switch (d->state.lineJoin) {
+ case Qt::RoundJoin:
+ return QLatin1String("round");
+ case Qt::BevelJoin:
+ return QLatin1String("bevel");
+ case Qt::MiterJoin:
+ return QLatin1String("miter");
+ default:
+ break;
+ }
+ return QLatin1String("");
+}
+
+void QSGContext2D::setLineJoin(const QString &joinString)
+{
+ Q_D(QSGContext2D);
+ d->setLineJoin(joinString);
+}
+
+qreal QSGContext2D::miterLimit() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.miterLimit;
+}
+
+void QSGContext2D::setMiterLimit(qreal m)
+{
+ Q_D(QSGContext2D);
+ d->setMiterLimit(m);
+}
+
+void QSGContext2D::setShadowOffsetX(qreal x)
+{
+ Q_D(QSGContext2D);
+ d->setShadowOffsetX(x);
+}
+
+void QSGContext2D::setShadowOffsetY(qreal y)
+{
+ Q_D(QSGContext2D);
+ d->setShadowOffsetY(y);
+}
+
+void QSGContext2D::setShadowBlur(qreal b)
+{
+ Q_D(QSGContext2D);
+ d->setShadowBlur(b);
+}
+
+void QSGContext2D::setShadowColor(const QString &str)
+{
+ Q_D(QSGContext2D);
+ d->setShadowColor(str);
+}
+
+QString QSGContext2D::textBaseline() const
+{
+ Q_D(const QSGContext2D);
+ switch(d->state.textBaseline) {
+ case QSGContext2D::Alphabetic:
+ return QLatin1String("alphabetic");
+ case QSGContext2D::Hanging:
+ return QLatin1String("hanging");
+ case QSGContext2D::Top:
+ return QLatin1String("top");
+ case QSGContext2D::Bottom:
+ return QLatin1String("bottom");
+ case QSGContext2D::Middle:
+ return QLatin1String("middle");
+ default:
+ break;
+ }
+ return QLatin1String("alphabetic");
+}
+
+void QSGContext2D::setTextBaseline(const QString &baseline)
+{
+ Q_D(QSGContext2D);
+ d->setTextBaseline(baseline);
+}
+
+QString QSGContext2D::textAlign() const
+{
+ Q_D(const QSGContext2D);
+ switch(d->state.textAlign) {
+ case QSGContext2D::Start:
+ return QLatin1String("start");
+ case QSGContext2D::End:
+ return QLatin1String("end");
+ case QSGContext2D::Left:
+ return QLatin1String("left");
+ case QSGContext2D::Right:
+ return QLatin1String("right");
+ case QSGContext2D::Center:
+ return QLatin1String("center");
+ default:
+ break;
+ }
+ return QLatin1String("start");
+}
+
+void QSGContext2D::setTextAlign(const QString &align)
+{
+ Q_D(QSGContext2D);
+ d->setTextAlign(align);
+
+ d->commands.push_back(QSGContext2D::TextAlign);
+ d->ints.push_back(d->state.textAlign);
+}
+
+void QSGContext2D::setFont(const QString &fontString)
+{
+ Q_D(QSGContext2D);
+ d->setFont(fontString);
+}
+
+QString QSGContext2D::font() const
+{
+ //### TODO
+ Q_D(const QSGContext2D);
+ return d->state.font.toString();
+}
+
+qreal QSGContext2D::shadowOffsetX() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.shadowOffsetX;
+}
+
+qreal QSGContext2D::shadowOffsetY() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.shadowOffsetY;
+}
+
+
+qreal QSGContext2D::shadowBlur() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.shadowBlur;
+}
+
+
+QString QSGContext2D::shadowColor() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.shadowColor.name();
+}
+
+
+void QSGContext2D::clearRect(qreal x, qreal y, qreal w, qreal h)
+{
+ Q_D(QSGContext2D);
+ d->clearRect(x, y, w, h);
+}
+
+void QSGContext2D::fillRect(qreal x, qreal y, qreal w, qreal h)
+{
+ Q_D(QSGContext2D);
+ d->fillRect(x, y, w, h);
+}
+
+int QSGContext2DPrivate::baseLineOffset(QSGContext2D::TextBaseLineType value, const QFontMetrics &metrics)
+{
+ int offset = 0;
+ switch (value) {
+ case QSGContext2D::Top:
+ break;
+ case QSGContext2D::Alphabetic:
+ case QSGContext2D::Middle:
+ case QSGContext2D::Hanging:
+ offset = metrics.ascent();
+ break;
+ case QSGContext2D::Bottom:
+ offset = metrics.height();
+ break;
+ }
+ return offset;
+}
+
+int QSGContext2DPrivate::textAlignOffset(QSGContext2D::TextAlignType value, const QFontMetrics &metrics, const QString &text)
+{
+ int offset = 0;
+ if (value == QSGContext2D::Start)
+ value = qApp->layoutDirection() == Qt::LeftToRight ? QSGContext2D::Left : QSGContext2D::Right;
+ else if (value == QSGContext2D::End)
+ value = qApp->layoutDirection() == Qt::LeftToRight ? QSGContext2D::Right: QSGContext2D::Left;
+ switch (value) {
+ case QSGContext2D::Center:
+ offset = metrics.width(text)/2;
+ break;
+ case QSGContext2D::Right:
+ offset = metrics.width(text);
+ case QSGContext2D::Left:
+ default:
+ break;
+ }
+ return offset;
+}
+
+void QSGContext2D::fillText(const QString &text, qreal x, qreal y)
+{
+ Q_D(QSGContext2D);
+ d->fillText(text, x, y);
+}
+
+void QSGContext2D::strokeText(const QString &text, qreal x, qreal y)
+{
+ Q_D(QSGContext2D);
+ d->strokeText(text, x, y);
+}
+
+void QSGContext2D::strokeRect(qreal x, qreal y, qreal w, qreal h)
+{
+ Q_D(QSGContext2D);
+ d->strokeRect(x, y, w, h);
+}
+
+void QSGContext2D::beginPath()
+{
+ Q_D(QSGContext2D);
+ d->beginPath();
+}
+
+
+void QSGContext2D::closePath()
+{
+ Q_D(QSGContext2D);
+ d->closePath();
+}
+
+
+void QSGContext2D::moveTo(qreal x, qreal y)
+{
+ Q_D(QSGContext2D);
+ d->moveTo(x, y);
+}
+
+
+void QSGContext2D::lineTo(qreal x, qreal y)
+{
+ Q_D(QSGContext2D);
+ d->lineTo(x, y);
+}
+
+
+void QSGContext2D::quadraticCurveTo(qreal cpx, qreal cpy, qreal x, qreal y)
+{
+ Q_D(QSGContext2D);
+ d->quadraticCurveTo(cpx, cpy, x, y);
+}
+
+
+void QSGContext2D::bezierCurveTo(qreal cp1x, qreal cp1y,
+ qreal cp2x, qreal cp2y, qreal x, qreal y)
+{
+ Q_D(QSGContext2D);
+ d->bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
+}
+
+
+void QSGContext2D::arcTo(qreal x1, qreal y1, qreal x2, qreal y2, qreal radius)
+{
+ Q_D(QSGContext2D);
+ d->arcTo(x1, y1, x2, y2, radius);
+}
+
+
+void QSGContext2D::rect(qreal x, qreal y, qreal w, qreal h)
+{
+ Q_D(QSGContext2D);
+ d->rect(x, y, w, h);
+}
+
+void QSGContext2D::arc(qreal xc, qreal yc, qreal radius,
+ qreal sar, qreal ear,
+ bool anticlockwise)
+{
+ Q_D(QSGContext2D);
+ d->arc(xc, yc, radius, sar, ear, anticlockwise);
+}
+
+
+void QSGContext2D::fill()
+{
+ Q_D(QSGContext2D);
+ d->fill();
+}
+
+
+void QSGContext2D::stroke()
+{
+ Q_D(QSGContext2D);
+ d->stroke();
+}
+
+
+void QSGContext2D::clip()
+{
+ Q_D(QSGContext2D);
+ d->clip();
+}
+
+
+bool QSGContext2D::isPointInPath(qreal x, qreal y) const
+{
+ Q_D(const QSGContext2D);
+ return d->path.contains(QPointF(x, y));
+}
+
+
+QList<int> QSGContext2D::getImageData(qreal sx, qreal sy, qreal sw, qreal sh)
+{
+ Q_D(QSGContext2D);
+ return d->getImageData(sx, sy, sw, sh);
+}
+
+void QSGContext2D::putImageData(const QVariant& imageData, qreal x, qreal y, qreal w, qreal h)
+{
+ Q_D(QSGContext2D);
+ return d->putImageData(imageData.toList(), x, y, w, h);
+}
+
+QSGContext2D::QSGContext2D(QObject *parent)
+ : QObject(*(new QSGContext2DPrivate()), parent)
+{
+ Q_D(QSGContext2D);
+ d->canvas = qobject_cast<QSGCanvasItem*>(parent);
+}
+
+QSGContext2D::QSGContext2D(QSGContext2D *orig, QSGContext2DWorkerAgent* agentData)
+ : QObject(*(new QSGContext2DPrivate()), 0)
+{
+ Q_D(QSGContext2D);
+ d->agent = 0;
+ d->agentData = agentData;
+ if (d->agentData) {
+ d->agentData->orig = orig;
+ }
+ d->canvas = qobject_cast<QSGCanvasItem*>(orig);
+}
+
+QSGContext2D::~QSGContext2D()
+{
+ Q_D(QSGContext2D);
+ if (d->agent) {
+ d->agentData->syncDone.wakeAll();
+ d->agent->release();
+ }
+}
+
+bool QSGContext2D::isDirty() const
+{
+ Q_D(const QSGContext2D);
+ return !d->commands.isEmpty();
+}
+
+QScriptValue QSGContext2D::scriptValue() const
+{
+ Q_D(const QSGContext2D);
+ return d->scriptValue;
+}
+
+void QSGContext2D::setScriptEngine(QScriptEngine *eng)
+{
+ Q_D(QSGContext2D);
+ if (d->scriptEngine != eng) {
+ d->scriptEngine = eng;
+// QScriptValue agent = d->scriptEngine->globalObject().property(QLatin1String("Context2DAgent"));
+// if (!agent.isValid()) {
+// d->scriptEngine->evaluate(QLatin1String(
+// "(function CanvasImageData(w, h, d) {"
+// " this.widht = w;"
+// " this.height = h;"
+// " this.data = d;"
+// " })"));
+// d->scriptEngine->evaluate(agentScript());
+// agent = d->scriptEngine->globalObject().property(QLatin1String("Context2DAgent"));
+// if (!agent.isValid()) {
+// qWarning() << "QSGContext2D:error when evaluating context2d script value!";
+// d->scriptValue = QScriptValue();
+// return;
+// }
+// }
+// QScriptValue o = d->scriptEngine->newQObject(this);
+// d->scriptValue = agent.construct(QScriptValueList() << o);
+ }
+}
+
+QScriptEngine *QSGContext2D::scriptEngine() const
+{
+ Q_D(const QSGContext2D);
+ return d->scriptEngine;
+}
+
+void QSGContext2D::addref()
+{
+ Q_D(QSGContext2D);
+ Q_ASSERT(d->agentData);
+ d->agentData->ref.ref();
+}
+
+void QSGContext2D::release()
+{
+ Q_D(QSGContext2D);
+ Q_ASSERT(d->agentData);
+ if (!d->agentData->ref.deref()) {
+ deleteLater();
+ }
+}
+
+
+bool QSGContext2D::inWorkerThread() const
+{
+ Q_D(const QSGContext2D);
+ return d->agentData != 0;
+}
+const QString& QSGContext2D::agentScript() const
+{
+ static QString script;
+ if (script.isEmpty()) {
+ script = QString::fromLatin1(
+ "function CanvasImageData(w, h, d) {"
+ " this.width = w;"
+ " this.height = h;"
+ " this.data = d;"
+ "}"
+ "function Context2DAgent(_ctx2d) {"
+ " this._ctx = _ctx2d;"
+ " this._fillColor = '#000000';"
+ " this._fillStyle = '#000000';"
+ " this._strokeColor = '#000000';"
+ " this._strokeStyle = '#000000';"
+ " this._globalCompositeOperation = \"source-over\";"
+ " this._commands = [];"
+ " this.createImageData = function() {"
+ " var d = null;"
+ " if (arguments.length == 1 && arguments[0] instanceof CanvasImageData) {"
+ " d = new CanvasImageData(arguments[0].width,"
+ " arguments[0].height,"
+ " new Array(arguments[0].width * arguments[0].height * 4));"
+ " } else if (arguments.length == 2) {"
+ " d = new CanvasImageData(arguments[0], arguments[1], new Array(arguments[0] * arguments[1] * 4));"
+ " }"
+ " if (d)"
+ " for (var i=0; i<d.data.length; i++)"
+ " d.data[i] = 255;"
+ " return d;"
+ " };"
+ " this.getImageData = function(sx, sy, sw, sh) {"
+ " var imageData = new CanvasImageData(sw, sh, this._ctx.getImageData(sx, sy, sw, sh));"
+ " return imageData;"
+ " };"
+ " this.sync = function() {"
+ " this._ctx.processCommands(this._commands);"
+ " this._commands.length = 0;"
+ " };");
+
+ script.append(QString::fromLatin1(
+ "this.save = function() {"
+ " this._commands.push([%1]);"
+ "};").arg(Save));
+
+ script.append(QString::fromLatin1(
+ "this.restore = function() {"
+ " this._commands.push([%1]);"
+ "};").arg(Restore));
+
+ script.append(QString::fromLatin1(
+ "this.scale = function(x, y) {"
+ " this._commands.push([%1, x, y]);"
+ "};").arg(Scale));
+
+ script.append(QString::fromLatin1(
+ "this.createImage = function(url) {"
+ " return this._ctx.createImage(url);"
+ "};"));
+
+ script.append(QString::fromLatin1(
+ "this.rotate = function(x) {"
+ " this._commands.push([%1, x]);"
+ "};").arg(Rotate));
+
+ script.append(QString::fromLatin1(
+ "this.translate = function(x, y) {"
+ " this._commands.push([%1, x, y]);"
+ "};").arg(Translate));
+
+ script.append(QString::fromLatin1(
+ "this.transform = function(a1, a2, a3, a4, a5, a6) {"
+ " this._commands.push([%1, a1, a2, a3, a4, a5, a6]);"
+ "};").arg(Transform));
+
+ script.append(QString::fromLatin1(
+ "this.setTransform = function(a1, a2, a3, a4, a5, a6) {"
+ " this._commands.push([%1, a1, a2, a3, a4, a5, a6]);"
+ "};").arg(SetTransform));
+
+ script.append(QString::fromLatin1(
+ "this.clearRect = function(x, y, w, h) {"
+ " this._commands.push([%1, x, y, w, h]);"
+ "};").arg(ClearRect));
+
+ script.append(QString::fromLatin1(
+ "this.fillRect = function(x, y, w, h) {"
+ " this._commands.push([%1, x, y, w, h]);"
+ "};").arg(FillRect));
+
+ script.append(QString::fromLatin1(
+ "this.strokeRect = function(x, y, w, h) {"
+ " this._commands.push([%1, x, y, w, h]);"
+ "};").arg(StrokeRect));
+
+ script.append(QString::fromLatin1(
+ "this.beginPath = function() {"
+ " this._commands.push([%1]);"
+ "};").arg(BeginPath));
+
+ script.append(QString::fromLatin1(
+ "this.closePath = function() {"
+ " this._commands.push([%1]);"
+ "};").arg(ClosePath));
+
+ script.append(QString::fromLatin1(
+ "this.moveTo = function(x, y) {"
+ " this._commands.push([%1, x, y]);"
+ "};").arg(MoveTo));
+
+ script.append(QString::fromLatin1(
+ "this.lineTo = function(x, y) {"
+ " this._commands.push([%1, x, y]);"
+ "};").arg(LineTo));
+
+ script.append(QString::fromLatin1(
+ "this.quadraticCurveTo = function(a1, a2, a3, a4) {"
+ " this._commands.push([%1, a1, a2, a3, a4]);"
+ "};").arg(QuadraticCurveTo));
+
+ script.append(QString::fromLatin1(
+ "this.bezierCurveTo = function(a1, a2, a3, a4, a5, a6) {"
+ " this._commands.push([%1, a1, a2, a3, a4, a5, a6]);"
+ "};").arg(BezierCurveTo));
+
+ script.append(QString::fromLatin1(
+ "this.arcTo = function(x1, y1, x2, y2, radius) {"
+ " this._commands.push([%1, x1, y1, x2, y2, radius]);"
+ "};").arg(ArcTo));
+
+ script.append(QString::fromLatin1(
+ "this.rect = function(x, y, w, h) {"
+ " this._commands.push([%1, x, y, w, h]);"
+ "};").arg(Rect));
+
+ script.append(QString::fromLatin1(
+ "this.rect = function(x, y, radius, startAngle, endAngle, anticlockwise) {"
+ " this._commands.push([%1, x, y, radius, startAngle, endAngle, anticlockwise]);"
+ "};").arg(Arc));
+
+ script.append(QString::fromLatin1(
+ "this.fill = function() {"
+ " this._commands.push([%1]);"
+ "};").arg(Fill));
+
+ script.append(QString::fromLatin1(
+ "this.stroke = function() {"
+ " this._commands.push([%1]);"
+ "};").arg(Stroke));
+
+ script.append(QString::fromLatin1(
+ "this.clip = function() {"
+ " this._commands.push([%1]);"
+ "};").arg(Clip));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"globalAlpha\", function() {"
+ " return this._globalAlpha;"
+ " });"
+ " this.__defineSetter__(\"globalAlpha\", function(v) {"
+ " this._globalAlpha = v;"
+ " this._commands.push([%1, v]);"
+ " });").arg(GlobalAlpha));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"globalCompositeOperation\", function() {"
+ " return this._globalCompositeOperation;"
+ " });"
+ " this.__defineSetter__(\"globalCompositeOperation\", function(v) {"
+ " this._globalCompositeOperation = v;"
+ " this._commands.push([%1, v]);"
+ " });").arg(GlobalCompositeOperation));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"strokeStyle\", function() {return this._strokeStyle; });"
+ " this.__defineSetter__(\"strokeStyle\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._strokeStyle = v;"
+ " });").arg(StrokeStyle));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"fillStyle\", function() {return this._fillStyle; });"
+ " this.__defineSetter__(\"fillStyle\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._fillStyle = v;"
+ " });").arg(FillStyle));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"strokeColor\", function() {return this._strokeColor; });"
+ " this.__defineSetter__(\"strokeColor\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._strokeColor = v;"
+ " });").arg(StrokeColor));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"fillColor\", function() {return this._fillColor; });"
+ " this.__defineSetter__(\"fillColor\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._fillColor = v;"
+ " });").arg(FillColor));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"lineWidth\", function() {return this._lineWidth; });"
+ " this.__defineSetter__(\"lineWidth\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._lineWidth = v;"
+ " });").arg(LineWidth));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"lineCap\", function() {return this._lineCap; });"
+ " this.__defineSetter__(\"lineCap\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._lineCap = v;"
+ " });").arg(LineCap));
+
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"lineJoin\", function() {return this._lineJoin; });"
+ " this.__defineSetter__(\"lineJoin\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._lineJoin = v;"
+ " });").arg(LineJoin));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"miterLimit\", function() {return this._miterLimit; });"
+ " this.__defineSetter__(\"miterLimit\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._miterLimit = v;"
+ " });").arg(MiterLimit));
+
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"shadowOffsetX\", function() {return this._shadowOffsetX; });"
+ " this.__defineSetter__(\"shadowOffsetX\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._shadowOffsetX = v;"
+ " });").arg(ShadowOffsetX));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"shadowOffsetY\", function() {return this._shadowOffsetY; });"
+ " this.__defineSetter__(\"shadowOffsetY\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._shadowOffsetY = v;"
+ " });").arg(ShadowOffsetY));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"shadowBlur\", function() {return this._shadowBlur; });"
+ " this.__defineSetter__(\"shadowBlur\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._shadowBlur = v;"
+ " });").arg(ShadowBlur));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"shadowColor\", function() {return this._shadowColor; });"
+ " this.__defineSetter__(\"shadowColor\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._shadowColor = v;"
+ " });").arg(ShadowColor));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"font\", function() {return this._font; });"
+ " this.__defineSetter__(\"font\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._font = v;"
+ " });").arg(Font));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"textBaseline\", function() {return this._textBaseline; });"
+ " this.__defineSetter__(\"textBaseline\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._textBaseline = v;"
+ " });").arg(TextBaseline));
+
+ script.append(QString::fromLatin1(
+ " this.__defineGetter__(\"textAlign\", function() {return this._textAlign; });"
+ " this.__defineSetter__(\"textAlign\", function(v) {"
+ " this._commands.push([%1, v]);"
+ " this._textAlign = v;"
+ " });").arg(TextAlign));
+
+ script.append(QString::fromLatin1(
+ "this.fillText = function(text, x, y) {"
+ " this._commands.push([%1, text, x, y]);"
+ "};").arg(FillText));
+
+ script.append(QString::fromLatin1(
+ "this.strokeText = function(text, x, y) {"
+ " this._commands.push([%1, text, x, y]);"
+ "};").arg(StrokeText));
+
+ script.append(QString::fromLatin1(
+ "this.drawImage = function() {"
+ " if (arguments.length == 3) {"
+ " this._commands.push([%1, arguments[0], arguments[1], arguments[2]]);"
+ " } else if (arguments.length == 5) {"
+ " this._commands.push([%2, arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]]);"
+ " } else if (arguments.length == 9) {"
+ " this._commands.push([%3, arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8]]);}"
+ "};").arg(DrawImage1).arg(DrawImage2).arg(DrawImage3));
+
+ script.append(QString::fromLatin1(
+ "this.putImageData = function() {"
+ " var dx = arguments[1];"
+ " var dy = arguments[2];"
+ " if (arguments.length == 3) {"
+ " this._commands.push([%1, arguments[0].data, dx, dy, arguments[0].width, arguments[0].height]);"
+ " } else if (arguments.length == 7) {"
+ " var dirtyX = arguments[3];"
+ " var dirtyY = arguments[4];"
+ " var dirtyWidth = arguments[5];"
+ " var dirtyHeight = arguments[6];"
+ " var width = arguments[0].width;"
+ " var height = arguments[0].heigh;"
+ " var filteredData = arguments[0].data.filter(function(element, index, array){"
+ " var x=index/width;"
+ " var y=index%width-1;"
+ " return x >= dirtyX && x < dirtyX+dirtyWidth"
+ " && y >= dirtyY && y < dirtyY+dirtyHeight;"
+ " });"
+ " this._commands.push([%2, filteredData, dx, dy, dirtyWidth, dirtyHeight]);"
+ " }"
+ "};").arg(PutImageData).arg(PutImageData));
+ script.append(QString::fromLatin1("}"));
+ }
+ return script;
+}
+
+QSGContext2D *QSGContext2D::agent()
+{
+ Q_D(QSGContext2D);
+
+ if (d->agent)
+ return d->agent;
+
+ d->agent = new QSGContext2D(this, new QSGContext2DWorkerAgent);
+ connect(this, SIGNAL(painted()), d->agent, SIGNAL(painted()));
+ d->agent->setSize(size());
+ return d->agent;
+
+}
+void QSGContext2D::processCommands(const QScriptValue& commands)
+{
+#ifdef QSGCANVASITEM_DEBUG
+ QElapsedTimer t;
+ t.start();
+#endif
+ int ii = 0;
+ if (commands.isArray()) {
+ QScriptValue cmd = commands.property(ii);
+ while(cmd.isValid()) {
+ processCommand(cmd);
+ ii++;
+ cmd = commands.property(ii);
+ }
+ }
+
+#ifdef QSGCANVASITEM_DEBUG
+ qDebug() << "processed" << ii << "commands in " << t.nsecsElapsed() << "nsecs";
+#endif
+ sync();
+}
+
+void QSGContext2D::sync()
+{
+ Q_D(QSGContext2D);
+
+#ifdef QSGCANVASITEM_DEBUG
+ QElapsedTimer t;
+ t.start();
+#endif
+ if (d->agentData) {
+ if (d->agentData->ref == 1) return;
+
+ Sync *s = new Sync;
+ s->data = d->agentData;
+
+ d->agentData->mutex.lock();
+ QCoreApplication::postEvent(this, s);
+ d->agentData->syncDone.wait(&d->agentData->mutex);
+ d->agentData->mutex.unlock();
+ } else {
+ //qmlInfo(this) << "Context2D sync() can only be called from a WorkerScript;";
+ emit changed();
+ }
+
+#ifdef QSGCANVASITEM_DEBUG
+ qDebug() << "syncing time:" << t.nsecsElapsed();
+#endif
+}
+
+
+bool QSGContext2D::event(QEvent *e)
+{
+ Q_D(QSGContext2D);
+ if (e->type() == QEvent::User && d->agentData) {
+ QMutexLocker locker(&d->agentData->mutex);
+ Sync *s = static_cast<Sync *>(e);
+
+ QSGContext2DPrivate* origin_d = static_cast<QSGContext2DPrivate*>(s->data->orig->d_func());
+
+ //quick copy
+ memcpy_vector<PaintCommand>(&origin_d->commands, d->commands);
+ memcpy_vector<int>(&origin_d->ints, d->ints);
+ memcpy_vector<qreal>(&origin_d->reals, d->reals);
+ memcpy_vector<QColor>(&origin_d->colors, d->colors);
+ memcpy_vector<QMatrix>(&origin_d->matrixes, d->matrixes);
+ memcpy_vector<QSize>(&origin_d->sizes, d->sizes);
+
+ //slow copy
+ copy_vector<QString>(&origin_d->strings, d->strings);
+ copy_vector<QVariant>(&origin_d->variants, d->variants);
+ copy_vector<QPen>(&origin_d->pens, d->pens);
+ copy_vector<QBrush>(&origin_d->brushes, d->brushes);
+ copy_vector<QPainterPath>(&origin_d->pathes, d->pathes);
+ copy_vector<QFont>(&origin_d->fonts, d->fonts);
+ copy_vector<QImage>(&origin_d->images, d->images);
+ origin_d->state = d->state;
+ d->clearCommands();
+
+ if (d->waitingForPainting) {
+ d->imageData.clear();
+ origin_d->imageData.clear();
+ emit s->data->orig->changed();
+ while(origin_d->imageData.isEmpty()) {
+ QCoreApplication::processEvents();
+ }
+ d->imageData = origin_d->imageData;
+ d->waitingForPainting = false;
+ qDebug() << "imageData size:" << d->imageData.size();
+ } else {
+ emit s->data->orig->changed();
+ }
+
+ d->agentData->syncDone.wakeAll();
+ return true;
+ }
+ return QObject::event(e);
+}
+
+void QSGContext2D::processCommand(const QScriptValue& cmd)
+{
+ int action = cmd.property(0).toInt32();
+ switch (action) {
+ case QSGContext2D::Save:
+ save();
+ break;
+ case QSGContext2D::Restore:
+ restore();
+ break;
+ case QSGContext2D::Scale:
+ scale(cmd.property(1).toNumber(), cmd.property(2).toNumber());
+ break;
+ case QSGContext2D::Rotate:
+ rotate(cmd.property(1).toNumber());
+ break;
+ case QSGContext2D::Translate:
+ translate(cmd.property(1).toNumber(), cmd.property(2).toNumber());
+ break;
+ case QSGContext2D::Transform:
+ transform(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber(),
+ cmd.property(5).toNumber(),
+ cmd.property(6).toNumber());
+ break;
+ case QSGContext2D::SetTransform:
+ setTransform(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber(),
+ cmd.property(5).toNumber(),
+ cmd.property(6).toNumber());
+ break;
+ case QSGContext2D::ClearRect:
+ clearRect(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber());
+ break;
+ case QSGContext2D::FillRect:
+ fillRect(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber());
+ break;
+ case QSGContext2D::StrokeRect:
+ strokeRect(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber());
+ break;
+ case QSGContext2D::BeginPath:
+ beginPath();
+ break;
+ case QSGContext2D::ClosePath:
+ closePath();
+ break;
+ case QSGContext2D::MoveTo:
+ moveTo(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber());
+ break;
+ case QSGContext2D::LineTo:
+ lineTo(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber());
+ break;
+ case QSGContext2D::QuadraticCurveTo:
+ quadraticCurveTo(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber());
+ break;
+ case QSGContext2D::BezierCurveTo:
+ bezierCurveTo(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber(),
+ cmd.property(5).toNumber(),
+ cmd.property(6).toNumber());
+ break;
+ case QSGContext2D::ArcTo:
+ arcTo(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber(),
+ cmd.property(5).toNumber());
+ break;
+ case QSGContext2D::Rect:
+ rect(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber());
+ break;
+ case QSGContext2D::Arc:
+ arc(cmd.property(1).toNumber(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber(),
+ cmd.property(5).toNumber(),
+ cmd.property(6).toBool());
+ break;
+ case QSGContext2D::Fill:
+ fill();
+ break;
+ case QSGContext2D::Stroke:
+ stroke();
+ break;
+ case QSGContext2D::Clip:
+ clip();
+ break;
+ case QSGContext2D::GlobalAlpha:
+ setGlobalAlpha(cmd.property(1).toNumber());
+ break;
+ case QSGContext2D::GlobalCompositeOperation:
+ setGlobalCompositeOperation(cmd.property(1).toString());
+ break;
+ case QSGContext2D::StrokeStyle:
+ setStrokeStyle(cmd.property(1).toVariant());
+ break;
+ case QSGContext2D::FillStyle:
+ setFillStyle(cmd.property(1).toVariant());
+ break;
+ case QSGContext2D::FillColor:
+ setFillColor(cmd.property(1).toVariant().value<QColor>());
+ break;
+ case QSGContext2D::StrokeColor:
+ setStrokeColor(cmd.property(1).toVariant().value<QColor>());
+ break;
+ case QSGContext2D::LineWidth:
+ setLineWidth(cmd.property(1).toNumber());
+ break;
+ case QSGContext2D::LineCap:
+ setLineCap(cmd.property(1).toString());
+ break;
+ case QSGContext2D::LineJoin:
+ setLineJoin(cmd.property(1).toString());
+ break;
+ case QSGContext2D::MiterLimit:
+ setMiterLimit(cmd.property(1).toNumber());
+ break;
+ case QSGContext2D::ShadowOffsetX:
+ setShadowOffsetX(cmd.property(1).toNumber());
+ break;
+ case QSGContext2D::ShadowOffsetY:
+ setShadowOffsetY(cmd.property(1).toNumber());
+ break;
+ case QSGContext2D::ShadowBlur:
+ setShadowBlur(cmd.property(1).toNumber());
+ break;
+ case QSGContext2D::ShadowColor:
+ setShadowColor(cmd.property(1).toString());
+ break;
+ case QSGContext2D::Font:
+ setFont(cmd.property(1).toString());
+ break;
+ case QSGContext2D::TextBaseline:
+ setTextBaseline(cmd.property(1).toString());
+ break;
+ case QSGContext2D::TextAlign:
+ setTextAlign(cmd.property(1).toString());
+ break;
+ case QSGContext2D::FillText:
+ fillText(cmd.property(1).toString(), cmd.property(2).toNumber(), cmd.property(3).toNumber());
+ break;
+ case QSGContext2D::StrokeText:
+ strokeText(cmd.property(1).toString(), cmd.property(2).toNumber(), cmd.property(3).toNumber());
+ break;
+ case QSGContext2D::DrawImage1:
+ {
+ drawImage(cmd.property(1).toString(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber());
+ break;
+ }
+ case QSGContext2D::DrawImage2:
+ drawImage(cmd.property(1).toString(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber(),
+ cmd.property(5).toNumber());
+ break;
+ case QSGContext2D::DrawImage3:
+ drawImage(cmd.property(1).toString(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber(),
+ cmd.property(5).toNumber(),
+ cmd.property(6).toNumber(),
+ cmd.property(7).toNumber(),
+ cmd.property(8).toNumber(),
+ cmd.property(9).toNumber());
+ break;
+ case QSGContext2D::PutImageData:
+ putImageData(cmd.property(1).toVariant(),
+ cmd.property(2).toNumber(),
+ cmd.property(3).toNumber(),
+ cmd.property(4).toNumber(),
+ cmd.property(5).toNumber());
+ break;
+ default:
+ break;
+ }
+}
+
+void QSGContext2D::paint(QPainter* p)
+{
+ Q_D(QSGContext2D);
+
+ QTransform transform = p->worldTransform();
+ if (!d->commands.isEmpty()) {
+ int matrix_idx, real_idx, int_idx, variant_idx, string_idx,color_idx,cmd_idx,
+ pen_idx, brush_idx, font_idx, path_idx, image_idx, size_idx;
+
+ matrix_idx = real_idx = int_idx = variant_idx = string_idx =color_idx = cmd_idx
+ = pen_idx = brush_idx = font_idx = path_idx = image_idx = size_idx = 0;
+
+ foreach(PaintCommand cmd, d->commands) {
+ switch (cmd) {
+ case UpdateMatrix:
+ {
+// qDebug() << "update matrix from " << d->state.matrix << " to " << d->matrixes[matrix_idx];
+ //p->setWorldTransform(transform * QTransform(d->matrixes[matrix_idx++]), false);
+ //p->setMatrix(d->matrixes[matrix_idx++]);
+ d->state.matrix = d->matrixes[matrix_idx++];
+ break;
+ }
+ case ClearRect:
+ {
+ qreal x = d->reals[real_idx++];
+ qreal y = d->reals[real_idx++];
+ qreal w = d->reals[real_idx++];
+ qreal h = d->reals[real_idx++];
+ p->eraseRect(QRectF(x, y, w, h));
+ break;
+ }
+ case FillRect:
+ {
+ qreal x = d->reals[real_idx++];
+ qreal y = d->reals[real_idx++];
+ qreal w = d->reals[real_idx++];
+ qreal h = d->reals[real_idx++];
+ if (d->hasShadow())
+ d->fillRectShadow(p, QRectF(x, y, w, h));
+ else
+ p->fillRect(QRectF(x, y, w, h), p->brush());
+ break;
+ }
+ case ShadowColor:
+ {
+ QColor c = d->colors[color_idx++];
+ d->state.shadowColor = c;
+ break;
+ }
+ case ShadowBlur:
+ {
+ qreal blur = d->reals[real_idx++];
+ d->state.shadowBlur = blur;
+ break;
+ }
+ case ShadowOffsetX:
+ {
+ qreal x = d->reals[real_idx++];
+ d->state.shadowOffsetX = x;
+ break;
+ }
+ case ShadowOffsetY:
+ {
+ qreal y = d->reals[real_idx++];
+ d->state.shadowOffsetY = y;
+ break;
+ }
+ case Fill:
+ {
+ QPainterPath path = d->pathes[path_idx++];
+ if (d->hasShadow())
+ d->fillShadowPath(p,path);
+ else
+ p->fillPath(path, p->brush());
+ break;
+ }
+ case Stroke:
+ {
+ p->setMatrix(d->state.matrix);
+ QPainterPath path = d->state.matrix.inverted().map(d->pathes[path_idx++]);
+ if (d->hasShadow())
+ d->strokeShadowPath(p,path);
+ else
+ p->strokePath(path, p->pen());
+ break;
+ }
+ case Clip:
+ {
+ QPainterPath clipPath = d->pathes[path_idx++];
+ p->setClipPath(clipPath);
+ p->setClipping(true);
+ break;
+ }
+ case UpdateBrush:
+ {
+ p->setBrush(d->brushes[brush_idx++]);
+ break;
+ }
+ case UpdatePen:
+ {
+ p->setPen(d->pens[pen_idx++]);
+ break;
+ }
+ case GlobalAlpha:
+ {
+ p->setOpacity(d->reals[real_idx++]);
+ break;
+ }
+ case GlobalCompositeOperation:
+ {
+ p->setCompositionMode(static_cast<QPainter::CompositionMode>(d->ints[int_idx++]));
+ break;
+ }
+ case Font:
+ {
+ p->setFont(d->fonts[font_idx++]);
+ break;
+ }
+ case StrokeText:
+ {
+ QString text = d->strings[string_idx++];
+ qreal x = d->reals[real_idx++];
+ qreal y = d->reals[real_idx++];
+ int align = d->ints[int_idx++];
+ int baseline = d->ints[int_idx++];
+
+ QPen oldPen = p->pen();
+ p->setPen(QPen(p->brush(),0));
+ //p->setMatrix(state.matrix, false); // always set?
+
+ QPainterPath textPath;
+ QFont oldFont = p->font();
+ QFont font = p->font();
+ font.setStyleStrategy(QFont::ForceOutline);
+ p->setFont(font);
+ const QFontMetrics &metrics = p->fontMetrics();
+ int yoffset = d->baseLineOffset(static_cast<QSGContext2D::TextBaseLineType>(baseline), metrics);
+ int xoffset = d->textAlignOffset(static_cast<QSGContext2D::TextAlignType>(align), metrics, text);
+ textPath.addText(x - xoffset, y - yoffset+metrics.ascent(), font, text);
+ if (d->hasShadow())
+ d->strokeShadowPath(p,textPath);
+
+ p->strokePath(textPath, QPen(p->brush(), p->pen().widthF()));
+
+ //reset old font
+ p->setFont(oldFont);
+ p->setPen(oldPen);
+ break;
+ }
+ case FillText:
+ {
+ QString text = d->strings[string_idx++];
+ qreal x = d->reals[real_idx++];
+ qreal y = d->reals[real_idx++];
+ int align = d->ints[int_idx++];
+ int baseline = d->ints[int_idx++];
+
+ QFont oldFont = p->font();
+ QPen oldPen = p->pen();
+ p->setPen(QPen(p->brush(), p->pen().widthF()));
+ //p->setMatrix(state.matrix, false);
+ //QFont font = p->font();
+ QFont font = d->state.font;
+ font.setBold(true);
+
+ p->setFont(font);
+ int yoffset = d->baseLineOffset(static_cast<QSGContext2D::TextBaseLineType>(baseline), p->fontMetrics());
+ int xoffset = d->textAlignOffset(static_cast<QSGContext2D::TextAlignType>(align), p->fontMetrics(), text);
+ QTextOption opt; // Adjust baseLine etc
+ if (d->hasShadow()) {
+ const QFontMetrics &metrics = p->fontMetrics();
+ QPainterPath textPath;
+ textPath.addText(x - xoffset, y - yoffset+metrics.ascent(), font, text);
+ d->fillShadowPath(p,textPath);
+ }
+ //p->drawText(QRectF(x - xoffset, y - yoffset, QWIDGETSIZE_MAX, p->fontMetrics().height()), text, opt);
+ p->setFont(oldFont);
+ p->setPen(oldPen);
+ break;
+ }
+ case DrawImage1:
+ {
+ QUrl url(d->strings[string_idx++]);
+ qreal x = d->reals[real_idx++];
+ qreal y = d->reals[real_idx++];
+ QDeclarativePixmap px(qmlEngine(d->canvas), url);
+ qDebug() << "draw image:" << url << px.pixmap().size();
+ if (px.isReady()) {
+ QPixmap pixmap = px.pixmap();
+ if (d->hasShadow()) {
+ QImage shadow = d->makeShadowImage(pixmap);
+ qreal dx = x + (d->state.shadowOffsetX < 0? d->state.shadowOffsetX:0);
+ qreal dy = y + (d->state.shadowOffsetY < 0? d->state.shadowOffsetY:0);
+ p->drawImage(QPointF(dx, dy), shadow);
+ }
+ p->drawPixmap(QPointF(x, y), pixmap);
+ }
+ break;
+ }
+ case DrawImage2:
+ {
+ qreal dx = d->reals[real_idx++];
+ qreal dy = d->reals[real_idx++];
+ qreal dw = d->reals[real_idx++];
+ qreal dh = d->reals[real_idx++];
+ QUrl url(d->strings[string_idx++]);
+ QDeclarativePixmap px(qmlEngine(d->canvas), url);
+ if (px.isReady()) {
+ QPixmap pixmap = px.pixmap().scaled(dw, dh);
+ if (d->hasShadow()) {
+ QImage shadow = d->makeShadowImage(pixmap);
+ qreal shadow_dx = dx + (d->state.shadowOffsetX < 0? d->state.shadowOffsetX:0);
+ qreal shadow_dy = dy + (d->state.shadowOffsetY < 0? d->state.shadowOffsetY:0);
+ p->drawImage(QPointF(shadow_dx, shadow_dy), shadow);
+ }
+ p->drawPixmap(QPointF(dx, dy), pixmap);
+ }
+ break;
+ }
+ case DrawImage3:
+ {
+ qreal sx = d->reals[real_idx++];
+ qreal sy = d->reals[real_idx++];
+ qreal sw = d->reals[real_idx++];
+ qreal sh = d->reals[real_idx++];
+ qreal dx = d->reals[real_idx++];
+ qreal dy = d->reals[real_idx++];
+ qreal dw = d->reals[real_idx++];
+ qreal dh = d->reals[real_idx++];
+ QUrl url(d->strings[string_idx++]);
+ QDeclarativePixmap px(qmlEngine(d->canvas), url);
+ if (px.isReady()) {
+ QPixmap pixmap = px.pixmap().copy(sx, sy, sw, sh).scaled(dw, dh);
+ if (d->hasShadow()) {
+ QImage shadow = d->makeShadowImage(pixmap);
+ qreal shadow_dx = dx + (d->state.shadowOffsetX < 0? d->state.shadowOffsetX:0);
+ qreal shadow_dy = dy + (d->state.shadowOffsetY < 0? d->state.shadowOffsetY:0);
+ p->drawImage(QPointF(shadow_dx, shadow_dy), shadow);
+ }
+ p->drawPixmap(QPointF(dx, dy), pixmap);
+ }
+ break;
+ }
+ case GetImageData:
+ {
+ qreal sx = d->reals[real_idx++];
+ qreal sy = d->reals[real_idx++];
+ qreal sw = d->reals[real_idx++];
+ qreal sh = d->reals[real_idx++];
+ QImage img = toImage().copy(sx, sy, sw, sh);
+ const uchar* data = img.constBits();
+ int i = 0;
+
+ while(i< img.byteCount()) {
+ //the stored order in QImage:BGRA
+ d->imageData << *(data+i+2);//R
+ d->imageData << *(data+i+1);//G
+ d->imageData << *(data+i);//B
+ d->imageData << *(data+i+3);//A
+ i+=4;
+ }
+ break;
+ }
+ case PutImageData:
+ {
+ QImage image = d->images[image_idx++];
+ qreal x = d->reals[real_idx++];
+ qreal y = d->reals[real_idx++];
+ p->drawImage(QPointF(x, y), image);
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ d->clearCommands();
+ }
+}
+
+QPaintDevice* QSGContext2D::paintDevice()
+{
+ Q_D(QSGContext2D);
+ return &d->cachedImage;
+}
+const QImage& QSGContext2D::toImage() const
+{
+ Q_D(const QSGContext2D);
+ return d->cachedImage;
+}
+bool QSGContext2D::requireCachedImage() const
+{
+ Q_D(const QSGContext2D);
+ return d->waitingForPainting;
+}
+void QSGContext2D::setCachedImage(const QImage& image)
+{
+ Q_D(QSGContext2D);
+#ifndef QSGCANVASITEM_PAINTING_ON_IMAGE
+ if (d->waitingForPainting) {
+ d->cachedImage = image;
+ d->waitingForPainting = false;
+ }
+#endif
+ if (inWorkerThread()) {
+ d->agent->setCachedImage(image);
+ }
+}
+
+void QSGContext2D::clear()
+{
+ Q_D(QSGContext2D);
+ d->clear();
+}
+
+void QSGContext2D::reset()
+{
+ Q_D(QSGContext2D);
+ d->reset();
+}
+
+void QSGContext2D::drawImage(const QString& imgUrl, qreal dx, qreal dy)
+{
+ Q_D(QSGContext2D);
+ if (!imgUrl.isEmpty())
+ d->drawImage(imgUrl, dx, dy);
+}
+
+void QSGContext2D::drawImage(const QString& imgUrl, qreal sx, qreal sy, qreal sw, qreal sh, qreal dx, qreal dy, qreal dw, qreal dh)
+{
+ Q_D(QSGContext2D);
+ if (!imgUrl.isEmpty())
+ d->drawImage(imgUrl, sx, sy, sw, sh, dx, dy, dw, dh);
+}
+
+void QSGContext2D::drawImage(const QString& imgUrl, qreal dx, qreal dy,
+ qreal dw, qreal dh)
+{
+ Q_D(QSGContext2D);
+ if (!imgUrl.isEmpty())
+ d->drawImage(imgUrl, dx, dy, dw, dh);
+}
+
+void QSGContext2D::setSize(int width, int height)
+{
+ QSize size(width, height);
+ setSize(size);
+}
+
+void QSGContext2D::setSize(const QSize &size)
+{
+ Q_D(QSGContext2D);
+
+ if (d->size == size)
+ return;
+ d->setSize(size);
+ emit changed();
+}
+
+QSize QSGContext2D::size() const
+{
+ Q_D(const QSGContext2D);
+ return d->size;
+}
+
+QMatrix QSGContext2D::worldMatrix() const
+{
+ Q_D(const QSGContext2D);
+ return d->state.matrix;
+}
+
+QT_END_NAMESPACE
projects / profile / ivi / qtdeclarative.git / commitdiff