plasma-framework/scriptengines/javascript/simplebindings/painter.cpp

1159 lines
40 KiB
C++
Raw Normal View History

/*
* Copyright 2007 Richard J. Moore <rich@kde.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License version 2 as
* published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <QtScript/QScriptValue>
#include <QtScript/QScriptEngine>
#include <QtScript/QScriptContext>
#include <QtGui/QPainter>
#include <QtGui/QPicture>
#include <QtGui/QPolygonF>
#include <QtGui/QWidget>
#include <QtCore/qdebug.h>
#include "backportglobal.h"
Q_DECLARE_METATYPE(QPolygonF)
Q_DECLARE_METATYPE(QPainterPath)
Q_DECLARE_METATYPE(QPainterPath*)
Q_DECLARE_METATYPE(QPicture)
Q_DECLARE_METATYPE(QVector<QRectF>)
Q_DECLARE_METATYPE(QPaintDevice*)
Q_DECLARE_METATYPE(QPaintEngine*)
DECLARE_POINTER_METATYPE(QPainter)
static QScriptValue newPainter(QScriptEngine *eng, QPainter *p)
{
return QScript::wrapPointer(eng, p);
}
/////////////////////////////////////////////////////////////
static QScriptValue ctor(QScriptContext *ctx, QScriptEngine *eng)
{
if (ctx->argumentCount() > 0) {
QPaintDevice *device = qscriptvalue_cast<QPaintDevice*>(ctx->argument(0));
if (!device) {
QPixmap *pixmap = qscriptvalue_cast<QPixmap *>(ctx->argument(0));
if (pixmap) {
return newPainter(eng, new QPainter(pixmap));
} else {
return newPainter(eng, new QPainter());
}
}
return newPainter(eng, new QPainter(device));
} else {
return newPainter(eng, new QPainter());
}
}
/////////////////////////////////////////////////////////////
static QScriptValue background(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, background);
return qScriptValueFromValue(eng, self->background());
}
/////////////////////////////////////////////////////////////
static QScriptValue backgroundMode(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, backgroundMode);
return QScriptValue(eng, static_cast<int>(self->backgroundMode()));
}
/////////////////////////////////////////////////////////////
static QScriptValue begin(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, begin);
QWidget *device = qscriptvalue_cast<QWidget*>(ctx->argument(0));
if (!device) {
return ctx->throwError(QScriptContext::TypeError,
"QPainter.prototype.begin: argument is not a QWidget");
}
return QScriptValue(eng, self->begin(device));
}
/////////////////////////////////////////////////////////////
static QScriptValue boundingRect(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, boundingRect);
QRect result;
if (ctx->argumentCount() == 3) {
result = self->boundingRect(qscriptvalue_cast<QRect>(ctx->argument(0)),
ctx->argument(1).toInt32(),
ctx->argument(2).toString());
} else if (ctx->argumentCount() == 6) {
result = self->boundingRect(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32(),
ctx->argument(4).toInt32(),
ctx->argument(5).toString());
}
return qScriptValueFromValue(eng, result);
}
/////////////////////////////////////////////////////////////
static QScriptValue brush(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, brush);
return qScriptValueFromValue(eng, self->brush());
}
/////////////////////////////////////////////////////////////
static QScriptValue brushOrigin(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, brushOrigin);
return qScriptValueFromValue(eng, self->brushOrigin());
}
/////////////////////////////////////////////////////////////
static QScriptValue clipPath(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, clipPath);
return qScriptValueFromValue(eng, self->clipPath());
}
/////////////////////////////////////////////////////////////
static QScriptValue clipRegion(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, clipRegion);
return qScriptValueFromValue(eng, self->clipRegion());
}
/////////////////////////////////////////////////////////////
static QScriptValue combinedMatrix(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, combinedMatrix);
return qScriptValueFromValue(eng, self->combinedMatrix());
}
/////////////////////////////////////////////////////////////
static QScriptValue combinedTransform(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, combinedTransform);
return qScriptValueFromValue(eng, self->combinedTransform());
}
/////////////////////////////////////////////////////////////
static QScriptValue compositionMode(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, compositionMode);
return QScriptValue(eng, static_cast<int>(self->compositionMode()));
}
/////////////////////////////////////////////////////////////
static QScriptValue drawArc(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawArc);
if (ctx->argumentCount() == 6) {
// drawArc(x, y, height, width, startAngle, spanAngle)
self->drawArc(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32(),
ctx->argument(4).toInt32(),
ctx->argument(5).toInt32());
} else if (ctx->argumentCount() == 3) {
// drawArc(rectangle, startAngle, spanAngle)
self->drawArc(qscriptvalue_cast<QRectF>(ctx->argument(0)),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32());
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawChord(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawChord);
if (ctx->argumentCount() == 6) {
// x, y, height, width, startAngle, spanAngle
self->drawChord(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32(),
ctx->argument(4).toInt32(),
ctx->argument(5).toInt32());
} else if (ctx->argumentCount() == 3) {
// rectangle, startAngle, spanAngle
self->drawChord(qscriptvalue_cast<QRectF>(ctx->argument(0)),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32());
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawConvexPolygon(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawConvexPolygon);
self->drawConvexPolygon(qscriptvalue_cast<QPolygonF>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawEllipse(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawEllipse);
if (ctx->argumentCount() == 4) {
// drawEllipse(x, y, width, height)
self->drawEllipse(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32());
} else if (ctx->argumentCount() == 1) {
// drawEllipse(rect)
self->drawEllipse(qscriptvalue_cast<QRectF>(ctx->argument(0)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawImage(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawImage);
if (ctx->argumentCount() == 2) {
// target, image
QScriptValue arg0 = ctx->argument(0);
QImage image = qscriptvalue_cast<QImage>(ctx->argument(1));
if (arg0.property("width").isValid()) {
self->drawImage(qscriptvalue_cast<QRectF>(arg0), image);
} else {
self->drawImage(qscriptvalue_cast<QPointF>(arg0), image);
}
} else if (ctx->argumentCount() == 3) {
// x, y, image
self->drawImage(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
qscriptvalue_cast<QImage>(ctx->argument(2)));
} else if (ctx->argumentCount() == 5) {
// x, y, width, height, image
self->drawImage(QRect(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32()),
qscriptvalue_cast<QImage>(ctx->argument(4)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawLine(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawLine);
if (ctx->argumentCount() == 4) {
// x1, y1, x2, y2
self->drawLine(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32());
} else if (ctx->argumentCount() == 2) {
// p1, p2
self->drawLine(qscriptvalue_cast<QPointF>(ctx->argument(0)),
qscriptvalue_cast<QPointF>(ctx->argument(1)));
} else if (ctx->argumentCount() == 1) {
// line
self->drawLine(qscriptvalue_cast<QLineF>(ctx->argument(0)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawLines(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawLines);
return ctx->throwError("QPainter.prototype.drawLines is not implemented");
// self->drawLines(qscriptvalue_cast<QVector<QLineF> >(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawPath(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawPath);
self->drawPath(qscriptvalue_cast<QPainterPath>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawPicture(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawPicture);
if (ctx->argumentCount() == 2) {
self->drawPicture(qscriptvalue_cast<QPointF>(ctx->argument(0)),
qscriptvalue_cast<QPicture>(ctx->argument(1)));
} else if (ctx->argumentCount() == 3) {
self->drawPicture(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
qscriptvalue_cast<QPicture>(ctx->argument(2)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawPie(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawPie);
if (ctx->argumentCount() == 6) {
// x, y, height, width, startAngle, spanAngle
self->drawPie(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32(),
ctx->argument(4).toInt32(),
ctx->argument(5).toInt32());
} else if (ctx->argumentCount() == 3) {
// rectangle, startAngle, spanAngle
self->drawPie(qscriptvalue_cast<QRectF>(ctx->argument(0)),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32());
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawPixmap(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawPixmap);
if (ctx->argumentCount() == 2) {
// target, pixmap
QScriptValue arg0 = ctx->argument(0);
QPixmap pixmap = qscriptvalue_cast<QPixmap>(ctx->argument(1));
if (arg0.property("width").isValid()) {
self->drawPixmap(qscriptvalue_cast<QRectF>(arg0), pixmap,
QRectF(0, 0, pixmap.width(), pixmap.height()));
} else {
self->drawPixmap(qscriptvalue_cast<QPointF>(arg0), pixmap);
}
} else if (ctx->argumentCount() == 3) {
// x, y, pixmap
self->drawPixmap(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
qscriptvalue_cast<QPixmap>(ctx->argument(2)));
} else if (ctx->argumentCount() == 5) {
// x, y, width, height, pixmap
self->drawPixmap(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32(),
qscriptvalue_cast<QPixmap>(ctx->argument(4)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawPoint(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawPoint);
if (ctx->argumentCount() == 2) {
// drawPoint(x, y)
self->drawPoint(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32());
} else if (ctx->argumentCount() == 1) {
// drawPoint(point)
self->drawPoint(qscriptvalue_cast<QPointF>(ctx->argument(0)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawPoints(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawPoints);
self->drawPoints(qscriptvalue_cast<QPolygonF>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawPolygon(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawPolygon);
// ### fillRule (2nd argument)
self->drawPolygon(qscriptvalue_cast<QPolygonF>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawPolyline(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawPolyline);
self->drawPolyline(qscriptvalue_cast<QPolygonF>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawRect(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawRect);
if (ctx->argumentCount() == 4) {
// x, y, width, height
self->drawRect(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32());
} else if (ctx->argumentCount() == 1) {
// rect
self->drawRect(qscriptvalue_cast<QRectF>(ctx->argument(0)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawRects(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawRects);
self->drawRects(qscriptvalue_cast<QVector<QRectF> >(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawRoundRect(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawRoundRect);
// ### xRnd, yRnd
if (ctx->argumentCount() >= 4) {
self->drawRoundRect(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32());
} else {
self->drawRoundRect(qscriptvalue_cast<QRectF>(ctx->argument(0)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawText(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawText);
if (ctx->argumentCount() == 3) {
// x, y, text
self->drawText(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toString());
} else if (ctx->argumentCount() == 2) {
QScriptValue arg0 = ctx->argument(0);
if (arg0.property("width").isValid()) {
self->drawText(qscriptvalue_cast<QRectF>(arg0),
ctx->argument(1).toString());
} else {
self->drawText(qscriptvalue_cast<QPointF>(arg0),
ctx->argument(1).toString());
}
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue drawTiledPixmap(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, drawTiledPixmap);
if (ctx->argumentCount() >= 5) {
// x, y, width, height, pixmap, sx, sy
self->drawTiledPixmap(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32(),
qscriptvalue_cast<QPixmap>(ctx->argument(4)),
ctx->argument(5).toInt32(),
ctx->argument(6).toInt32());
} else {
// rect, pixmap, position
self->drawTiledPixmap(qscriptvalue_cast<QRectF>(ctx->argument(0)),
qscriptvalue_cast<QPixmap>(ctx->argument(1)),
qscriptvalue_cast<QPointF>(ctx->argument(2)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue end(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, end);
return QScriptValue(eng, self->end());
}
/////////////////////////////////////////////////////////////
static QScriptValue eraseRect(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, eraseRect);
if (ctx->argumentCount() == 4) {
// x, y, width, height
self->eraseRect(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32());
} else if (ctx->argumentCount() == 1) {
// rect
self->eraseRect(qscriptvalue_cast<QRectF>(ctx->argument(0)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue fillPath(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, fillPath);
QPainterPath *path = qscriptvalue_cast<QPainterPath*>(ctx->argument(0));
if (!path) {
return ctx->throwError(QScriptContext::TypeError,
"QPainter.prototype.fillPath: argument is not a PainterPath");
}
self->fillPath(*path, qscriptvalue_cast<QBrush>(ctx->argument(1)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue fillRect(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, fillRect);
if (ctx->argumentCount() == 5) {
// x, y, width, height, brush
self->fillRect(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32(),
qscriptvalue_cast<QBrush>(ctx->argument(4)));
} else if (ctx->argumentCount() == 2) {
// rect, brush
self->fillRect(qscriptvalue_cast<QRectF>(ctx->argument(0)),
qscriptvalue_cast<QBrush>(ctx->argument(1)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue font(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, font);
return qScriptValueFromValue(eng, self->font());
}
/////////////////////////////////////////////////////////////
static QScriptValue hasClipping(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, hasClipping);
return QScriptValue(eng, self->hasClipping());
}
/////////////////////////////////////////////////////////////
static QScriptValue active(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, active);
return QScriptValue(eng, self->isActive());
}
/////////////////////////////////////////////////////////////
static QScriptValue layoutDirection(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, layoutDirection);
return QScriptValue(eng, static_cast<int>(self->layoutDirection()));
}
/////////////////////////////////////////////////////////////
static QScriptValue opacity(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, opacity);
return QScriptValue(eng, self->opacity());
}
/////////////////////////////////////////////////////////////
static QScriptValue pen(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, pen);
return qScriptValueFromValue(eng, self->pen());
}
/////////////////////////////////////////////////////////////
static QScriptValue renderHints(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, renderHints);
return QScriptValue(eng, static_cast<int>(self->renderHints()));
}
/////////////////////////////////////////////////////////////
static QScriptValue resetMatrix(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, resetMatrix);
self->resetMatrix();
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue resetTransform(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, resetTransform);
self->resetTransform();
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue restore(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, restore);
self->restore();
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue rotate(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, rotate);
self->rotate(ctx->argument(0).toNumber());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue save(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, save);
self->save();
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue scale(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, scale);
self->scale(ctx->argument(0).toNumber(),
ctx->argument(1).toNumber());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setBackground(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setBackground);
self->setBackground(qscriptvalue_cast<QBrush>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setBackgroundMode(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setBackgroundMode);
self->setBackgroundMode(static_cast<Qt::BGMode>(ctx->argument(0).toInt32()));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setBrush(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setBrush);
self->setBrush(qscriptvalue_cast<QBrush>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setBrushOrigin(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setBrushOrigin);
self->setBrushOrigin(qscriptvalue_cast<QPointF>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setClipPath(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setClipPath);
// ### ClipOperation
self->setClipPath(qscriptvalue_cast<QPainterPath>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setClipRect(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setClipRect);
// ### ClipOperation
if (ctx->argumentCount() >= 4) {
// x, y, width, height [, operation]
self->setClipRect(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32());
} else if (ctx->argumentCount() >= 1) {
// rect [, operation]
self->setClipRect(qscriptvalue_cast<QRectF>(ctx->argument(0)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setClipRegion(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setClipRegion);
// ### ClipOperation
self->setClipRegion(qscriptvalue_cast<QRegion>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setClipping(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setClipping);
self->setClipping(ctx->argument(0).toBoolean());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setCompositionMode(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setCompositionMode);
self->setCompositionMode(static_cast<QPainter::CompositionMode>(ctx->argument(0).toInt32()));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setFont(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setFont);
self->setFont(qscriptvalue_cast<QFont>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setLayoutDirection(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setLayoutDirection);
self->setLayoutDirection(static_cast<Qt::LayoutDirection>(ctx->argument(0).toInt32()));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setOpacity(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setOpacity);
self->setOpacity(ctx->argument(0).toNumber());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setPen(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setPen);
self->setPen(qscriptvalue_cast<QPen>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setRenderHint(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setRenderHint);
self->setRenderHint(static_cast<QPainter::RenderHint>(ctx->argument(0).toInt32()),
ctx->argument(1).toBoolean());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setRenderHints(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setRenderHints);
self->setRenderHints(static_cast<QPainter::RenderHints>(ctx->argument(0).toInt32()),
ctx->argument(1).toBoolean());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setTransform(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setTransform);
self->setTransform(qscriptvalue_cast<QTransform>(ctx->argument(0)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setViewTransformEnabled(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setViewTransformEnabled);
self->setViewTransformEnabled(ctx->argument(0).toBoolean());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setViewport(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setViewport);
if (ctx->argumentCount() == 4) {
// x, y, width, height
self->setViewport(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32());
} else if (ctx->argumentCount() == 1) {
// rect
self->setViewport(qscriptvalue_cast<QRect>(ctx->argument(0)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setWindow(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setWindow);
if (ctx->argumentCount() == 4) {
// x, y, width, height
self->setWindow(ctx->argument(0).toInt32(),
ctx->argument(1).toInt32(),
ctx->argument(2).toInt32(),
ctx->argument(3).toInt32());
} else if (ctx->argumentCount() == 1) {
// rect
self->setWindow(qscriptvalue_cast<QRect>(ctx->argument(0)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setWorldMatrix(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setWorldMatrix);
self->setWorldMatrix(qscriptvalue_cast<QMatrix>(ctx->argument(0)),
ctx->argument(1).toBoolean());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setWorldMatrixEnabled(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setWorldMatrixEnabled);
self->setWorldMatrixEnabled(ctx->argument(0).toBoolean());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue setWorldTransform(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, setWorldTransform);
self->setWorldTransform(qscriptvalue_cast<QTransform>(ctx->argument(0)),
ctx->argument(1).toBoolean());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue shear(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, shear);
self->shear(ctx->argument(0).toNumber(),
ctx->argument(1).toNumber());
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue strokePath(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, strokePath);
QPainterPath *path = qscriptvalue_cast<QPainterPath*>(ctx->argument(0));
if (!path) {
return ctx->throwError(QScriptContext::TypeError,
"QPainter.prototype.strokePath: argument is not a PainterPath");
}
self->strokePath(*path, qscriptvalue_cast<QPen>(ctx->argument(1)));
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue testRenderHint(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, testRenderHint);
return QScriptValue(eng, self->testRenderHint(static_cast<QPainter::RenderHint>(ctx->argument(0).toInt32())));
}
/////////////////////////////////////////////////////////////
static QScriptValue transform(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, transform);
return qScriptValueFromValue(eng, self->transform());
}
/////////////////////////////////////////////////////////////
static QScriptValue translate(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, translate);
if (ctx->argumentCount() == 2) {
// dx, dy
self->translate(ctx->argument(0).toNumber(),
ctx->argument(1).toNumber());
} else if (ctx->argumentCount() == 1) {
// offset
self->translate(qscriptvalue_cast<QPointF>(ctx->argument(0)));
}
return eng->undefinedValue();
}
/////////////////////////////////////////////////////////////
static QScriptValue viewTransformEnabled(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, viewTransformEnabled);
return QScriptValue(eng, self->viewTransformEnabled());
}
/////////////////////////////////////////////////////////////
static QScriptValue viewport(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, viewport);
return qScriptValueFromValue(eng, self->viewport());
}
/////////////////////////////////////////////////////////////
static QScriptValue window(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, window);
return qScriptValueFromValue(eng, self->window());
}
/////////////////////////////////////////////////////////////
static QScriptValue worldMatrix(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, worldMatrix);
return qScriptValueFromValue(eng, self->worldMatrix());
}
/////////////////////////////////////////////////////////////
static QScriptValue worldMatrixEnabled(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, worldMatrixEnabled);
return QScriptValue(eng, self->worldMatrixEnabled());
}
/////////////////////////////////////////////////////////////
static QScriptValue worldTransform(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, worldTransform);
return qScriptValueFromValue(eng, self->worldTransform());
}
/////////////////////////////////////////////////////////////
static QScriptValue toString(QScriptContext *ctx, QScriptEngine *eng)
{
DECLARE_SELF(QPainter, toString);
return QScriptValue(eng, "QPainter");
}
/////////////////////////////////////////////////////////////
QScriptValue constructPainterClass(QScriptEngine *eng)
{
QScriptValue proto = newPainter(eng, new QPainter());
QScriptValue::PropertyFlags getter = QScriptValue::PropertyGetter;
QScriptValue::PropertyFlags setter = QScriptValue::PropertySetter;
proto.setProperty("background", eng->newFunction(background), getter);
proto.setProperty("background", eng->newFunction(setBackground), setter);
proto.setProperty("backgroundMode", eng->newFunction(backgroundMode), getter);
proto.setProperty("backgroundMode", eng->newFunction(setBackgroundMode), setter);
proto.setProperty("brush", eng->newFunction(brush), getter);
proto.setProperty("brush", eng->newFunction(setBrush), setter);
proto.setProperty("brushOrigin", eng->newFunction(brushOrigin), getter);
proto.setProperty("brushOrigin", eng->newFunction(setBrushOrigin), setter);
proto.setProperty("clipping", eng->newFunction(hasClipping), getter);
proto.setProperty("clipping", eng->newFunction(setClipping), getter);
proto.setProperty("clipPath", eng->newFunction(clipPath), getter);
proto.setProperty("clipPath", eng->newFunction(setClipPath), setter);
proto.setProperty("clipRegion", eng->newFunction(clipRegion), getter);
proto.setProperty("clipRegion", eng->newFunction(setClipRegion), setter);
proto.setProperty("compositionMode", eng->newFunction(compositionMode), getter);
proto.setProperty("compositionMode", eng->newFunction(setCompositionMode), setter);
proto.setProperty("font", eng->newFunction(font), getter);
proto.setProperty("font", eng->newFunction(setFont), setter);
proto.setProperty("layoutDirection", eng->newFunction(layoutDirection), getter);
proto.setProperty("layoutDirection", eng->newFunction(setLayoutDirection), setter);
proto.setProperty("opacity", eng->newFunction(opacity), getter);
proto.setProperty("opacity", eng->newFunction(setOpacity), setter);
proto.setProperty("pen", eng->newFunction(pen), getter);
proto.setProperty("pen", eng->newFunction(setPen), setter);
proto.setProperty("renderHints", eng->newFunction(renderHints), getter);
proto.setProperty("renderHints", eng->newFunction(setRenderHints), setter);
proto.setProperty("transform", eng->newFunction(transform), getter);
proto.setProperty("transform", eng->newFunction(setTransform), getter);
proto.setProperty("viewport", eng->newFunction(viewport), getter);
proto.setProperty("viewport", eng->newFunction(setViewport), setter);
proto.setProperty("viewTransformEnabled", eng->newFunction(viewTransformEnabled), getter);
proto.setProperty("viewTransformEnabled", eng->newFunction(setViewTransformEnabled), setter);
proto.setProperty("window", eng->newFunction(window), getter);
proto.setProperty("window", eng->newFunction(setWindow), setter);
proto.setProperty("worldMatrix", eng->newFunction(worldMatrix), getter);
proto.setProperty("worldMatrix", eng->newFunction(setWorldMatrix), setter);
proto.setProperty("worldTransform", eng->newFunction(worldTransform), getter);
proto.setProperty("worldTransform", eng->newFunction(setWorldTransform), setter);
proto.setProperty("worldMatrixEnabled", eng->newFunction(worldMatrixEnabled), getter);
proto.setProperty("worldMatrixEnabled", eng->newFunction(setWorldMatrixEnabled), setter);
proto.setProperty("combinedMatrix", eng->newFunction(combinedMatrix), getter);
proto.setProperty("combinedTransform", eng->newFunction(combinedTransform), getter);
proto.setProperty("active", eng->newFunction(active), getter);
ADD_METHOD(proto, begin);
ADD_METHOD(proto, end);
ADD_METHOD(proto, boundingRect);
ADD_METHOD(proto, drawChord);
ADD_METHOD(proto, drawConvexPolygon);
ADD_METHOD(proto, drawArc);
ADD_METHOD(proto, drawEllipse);
ADD_METHOD(proto, drawImage);
ADD_METHOD(proto, drawLine);
ADD_METHOD(proto, drawLines);
ADD_METHOD(proto, drawPath);
ADD_METHOD(proto, drawPicture);
ADD_METHOD(proto, drawPie);
ADD_METHOD(proto, drawPixmap);
ADD_METHOD(proto, drawPoint);
ADD_METHOD(proto, drawPoints);
ADD_METHOD(proto, drawPolygon);
ADD_METHOD(proto, drawPolyline);
ADD_METHOD(proto, drawRect);
ADD_METHOD(proto, drawRects);
ADD_METHOD(proto, drawRoundRect);
ADD_METHOD(proto, drawText);
ADD_METHOD(proto, drawTiledPixmap);
ADD_METHOD(proto, eraseRect);
ADD_METHOD(proto, fillPath);
ADD_METHOD(proto, fillRect);
ADD_METHOD(proto, resetMatrix);
ADD_METHOD(proto, resetTransform);
ADD_METHOD(proto, restore);
ADD_METHOD(proto, rotate);
ADD_METHOD(proto, save);
ADD_METHOD(proto, scale);
ADD_METHOD(proto, setClipRect);
ADD_METHOD(proto, setRenderHint);
ADD_METHOD(proto, shear);
ADD_METHOD(proto, strokePath);
ADD_METHOD(proto, testRenderHint);
ADD_METHOD(proto, toString);
ADD_METHOD(proto, translate);
QScript::registerPointerMetaType<QPainter>(eng, proto);
qScriptRegisterSequenceMetaType<QVector<QRectF> >(eng);
QScriptValue ctorFun = eng->newFunction(ctor, proto);
ADD_ENUM_VALUE(ctorFun, QPainter, Antialiasing);
ADD_ENUM_VALUE(ctorFun, QPainter, TextAntialiasing);
ADD_ENUM_VALUE(ctorFun, QPainter, SmoothPixmapTransform);
ADD_ENUM_VALUE(ctorFun, QPainter, HighQualityAntialiasing);
eng->setDefaultPrototype(qMetaTypeId<QPainter*>(), proto);
return ctorFun;
}