mirror of
https://github.com/mappu/miqt.git
synced 2024-12-22 08:58:37 +00:00
1031 lines
31 KiB
C++
1031 lines
31 KiB
C++
#include <QBrush>
|
|
#include <QFont>
|
|
#include <QImage>
|
|
#include <QLine>
|
|
#include <QLineF>
|
|
#include <QPaintDevice>
|
|
#include <QPaintEngine>
|
|
#include <QPaintEngineState>
|
|
#include <QPainter>
|
|
#include <QPainterPath>
|
|
#include <QPen>
|
|
#include <QPixmap>
|
|
#include <QPoint>
|
|
#include <QPointF>
|
|
#include <QRect>
|
|
#include <QRectF>
|
|
#include <QRegion>
|
|
#include <QSize>
|
|
#include <QString>
|
|
#include <QByteArray>
|
|
#include <cstring>
|
|
#include <QTextItem>
|
|
#include <QTransform>
|
|
#include <qpaintengine.h>
|
|
#include "gen_qpaintengine.h"
|
|
|
|
#ifndef _Bool
|
|
#define _Bool bool
|
|
#endif
|
|
#include "_cgo_export.h"
|
|
|
|
double QTextItem_Descent(const QTextItem* self) {
|
|
qreal _ret = self->descent();
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
double QTextItem_Ascent(const QTextItem* self) {
|
|
qreal _ret = self->ascent();
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
double QTextItem_Width(const QTextItem* self) {
|
|
qreal _ret = self->width();
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
int QTextItem_RenderFlags(const QTextItem* self) {
|
|
QTextItem::RenderFlags _ret = self->renderFlags();
|
|
return static_cast<int>(_ret);
|
|
}
|
|
|
|
struct miqt_string QTextItem_Text(const QTextItem* self) {
|
|
QString _ret = self->text();
|
|
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
|
|
QByteArray _b = _ret.toUtf8();
|
|
struct miqt_string _ms;
|
|
_ms.len = _b.length();
|
|
_ms.data = static_cast<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _b.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
QFont* QTextItem_Font(const QTextItem* self) {
|
|
return new QFont(self->font());
|
|
}
|
|
|
|
void QTextItem_Delete(QTextItem* self, bool isSubclass) {
|
|
if (isSubclass) {
|
|
delete dynamic_cast<QTextItem*>( self );
|
|
} else {
|
|
delete self;
|
|
}
|
|
}
|
|
|
|
class MiqtVirtualQPaintEngine : public virtual QPaintEngine {
|
|
public:
|
|
|
|
MiqtVirtualQPaintEngine(): QPaintEngine() {};
|
|
MiqtVirtualQPaintEngine(QPaintEngine::PaintEngineFeatures features): QPaintEngine(features) {};
|
|
|
|
virtual ~MiqtVirtualQPaintEngine() = default;
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Begin = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool begin(QPaintDevice* pdev) override {
|
|
if (handle__Begin == 0) {
|
|
return false; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
QPaintDevice* sigval1 = pdev;
|
|
|
|
bool callback_return_value = miqt_exec_callback_QPaintEngine_Begin(this, handle__Begin, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__End = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool end() override {
|
|
if (handle__End == 0) {
|
|
return false; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
bool callback_return_value = miqt_exec_callback_QPaintEngine_End(this, handle__End);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__UpdateState = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void updateState(const QPaintEngineState& state) override {
|
|
if (handle__UpdateState == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
const QPaintEngineState& state_ret = state;
|
|
// Cast returned reference into pointer
|
|
QPaintEngineState* sigval1 = const_cast<QPaintEngineState*>(&state_ret);
|
|
|
|
miqt_exec_callback_QPaintEngine_UpdateState(this, handle__UpdateState, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawRects = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawRects(const QRect* rects, int rectCount) override {
|
|
if (handle__DrawRects == 0) {
|
|
QPaintEngine::drawRects(rects, rectCount);
|
|
return;
|
|
}
|
|
|
|
QRect* sigval1 = (QRect*) rects;
|
|
int sigval2 = rectCount;
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawRects(this, handle__DrawRects, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawRects(QRect* rects, int rectCount) {
|
|
|
|
QPaintEngine::drawRects(rects, static_cast<int>(rectCount));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawRects2 = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawRects(const QRectF* rects, int rectCount) override {
|
|
if (handle__DrawRects2 == 0) {
|
|
QPaintEngine::drawRects(rects, rectCount);
|
|
return;
|
|
}
|
|
|
|
QRectF* sigval1 = (QRectF*) rects;
|
|
int sigval2 = rectCount;
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawRects2(this, handle__DrawRects2, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawRects2(QRectF* rects, int rectCount) {
|
|
|
|
QPaintEngine::drawRects(rects, static_cast<int>(rectCount));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawLines = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawLines(const QLine* lines, int lineCount) override {
|
|
if (handle__DrawLines == 0) {
|
|
QPaintEngine::drawLines(lines, lineCount);
|
|
return;
|
|
}
|
|
|
|
QLine* sigval1 = (QLine*) lines;
|
|
int sigval2 = lineCount;
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawLines(this, handle__DrawLines, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawLines(QLine* lines, int lineCount) {
|
|
|
|
QPaintEngine::drawLines(lines, static_cast<int>(lineCount));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawLines2 = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawLines(const QLineF* lines, int lineCount) override {
|
|
if (handle__DrawLines2 == 0) {
|
|
QPaintEngine::drawLines(lines, lineCount);
|
|
return;
|
|
}
|
|
|
|
QLineF* sigval1 = (QLineF*) lines;
|
|
int sigval2 = lineCount;
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawLines2(this, handle__DrawLines2, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawLines2(QLineF* lines, int lineCount) {
|
|
|
|
QPaintEngine::drawLines(lines, static_cast<int>(lineCount));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawEllipse = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawEllipse(const QRectF& r) override {
|
|
if (handle__DrawEllipse == 0) {
|
|
QPaintEngine::drawEllipse(r);
|
|
return;
|
|
}
|
|
|
|
const QRectF& r_ret = r;
|
|
// Cast returned reference into pointer
|
|
QRectF* sigval1 = const_cast<QRectF*>(&r_ret);
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawEllipse(this, handle__DrawEllipse, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawEllipse(QRectF* r) {
|
|
|
|
QPaintEngine::drawEllipse(*r);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawEllipseWithQRect = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawEllipse(const QRect& r) override {
|
|
if (handle__DrawEllipseWithQRect == 0) {
|
|
QPaintEngine::drawEllipse(r);
|
|
return;
|
|
}
|
|
|
|
const QRect& r_ret = r;
|
|
// Cast returned reference into pointer
|
|
QRect* sigval1 = const_cast<QRect*>(&r_ret);
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawEllipseWithQRect(this, handle__DrawEllipseWithQRect, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawEllipseWithQRect(QRect* r) {
|
|
|
|
QPaintEngine::drawEllipse(*r);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawPath = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawPath(const QPainterPath& path) override {
|
|
if (handle__DrawPath == 0) {
|
|
QPaintEngine::drawPath(path);
|
|
return;
|
|
}
|
|
|
|
const QPainterPath& path_ret = path;
|
|
// Cast returned reference into pointer
|
|
QPainterPath* sigval1 = const_cast<QPainterPath*>(&path_ret);
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawPath(this, handle__DrawPath, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawPath(QPainterPath* path) {
|
|
|
|
QPaintEngine::drawPath(*path);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawPoints = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawPoints(const QPointF* points, int pointCount) override {
|
|
if (handle__DrawPoints == 0) {
|
|
QPaintEngine::drawPoints(points, pointCount);
|
|
return;
|
|
}
|
|
|
|
QPointF* sigval1 = (QPointF*) points;
|
|
int sigval2 = pointCount;
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawPoints(this, handle__DrawPoints, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawPoints(QPointF* points, int pointCount) {
|
|
|
|
QPaintEngine::drawPoints(points, static_cast<int>(pointCount));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawPoints2 = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawPoints(const QPoint* points, int pointCount) override {
|
|
if (handle__DrawPoints2 == 0) {
|
|
QPaintEngine::drawPoints(points, pointCount);
|
|
return;
|
|
}
|
|
|
|
QPoint* sigval1 = (QPoint*) points;
|
|
int sigval2 = pointCount;
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawPoints2(this, handle__DrawPoints2, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawPoints2(QPoint* points, int pointCount) {
|
|
|
|
QPaintEngine::drawPoints(points, static_cast<int>(pointCount));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawPolygon = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawPolygon(const QPointF* points, int pointCount, QPaintEngine::PolygonDrawMode mode) override {
|
|
if (handle__DrawPolygon == 0) {
|
|
QPaintEngine::drawPolygon(points, pointCount, mode);
|
|
return;
|
|
}
|
|
|
|
QPointF* sigval1 = (QPointF*) points;
|
|
int sigval2 = pointCount;
|
|
QPaintEngine::PolygonDrawMode mode_ret = mode;
|
|
int sigval3 = static_cast<int>(mode_ret);
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawPolygon(this, handle__DrawPolygon, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawPolygon(QPointF* points, int pointCount, int mode) {
|
|
|
|
QPaintEngine::drawPolygon(points, static_cast<int>(pointCount), static_cast<QPaintEngine::PolygonDrawMode>(mode));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawPolygon2 = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawPolygon(const QPoint* points, int pointCount, QPaintEngine::PolygonDrawMode mode) override {
|
|
if (handle__DrawPolygon2 == 0) {
|
|
QPaintEngine::drawPolygon(points, pointCount, mode);
|
|
return;
|
|
}
|
|
|
|
QPoint* sigval1 = (QPoint*) points;
|
|
int sigval2 = pointCount;
|
|
QPaintEngine::PolygonDrawMode mode_ret = mode;
|
|
int sigval3 = static_cast<int>(mode_ret);
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawPolygon2(this, handle__DrawPolygon2, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawPolygon2(QPoint* points, int pointCount, int mode) {
|
|
|
|
QPaintEngine::drawPolygon(points, static_cast<int>(pointCount), static_cast<QPaintEngine::PolygonDrawMode>(mode));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawPixmap = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawPixmap(const QRectF& r, const QPixmap& pm, const QRectF& sr) override {
|
|
if (handle__DrawPixmap == 0) {
|
|
return; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
const QRectF& r_ret = r;
|
|
// Cast returned reference into pointer
|
|
QRectF* sigval1 = const_cast<QRectF*>(&r_ret);
|
|
const QPixmap& pm_ret = pm;
|
|
// Cast returned reference into pointer
|
|
QPixmap* sigval2 = const_cast<QPixmap*>(&pm_ret);
|
|
const QRectF& sr_ret = sr;
|
|
// Cast returned reference into pointer
|
|
QRectF* sigval3 = const_cast<QRectF*>(&sr_ret);
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawPixmap(this, handle__DrawPixmap, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawTextItem = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawTextItem(const QPointF& p, const QTextItem& textItem) override {
|
|
if (handle__DrawTextItem == 0) {
|
|
QPaintEngine::drawTextItem(p, textItem);
|
|
return;
|
|
}
|
|
|
|
const QPointF& p_ret = p;
|
|
// Cast returned reference into pointer
|
|
QPointF* sigval1 = const_cast<QPointF*>(&p_ret);
|
|
const QTextItem& textItem_ret = textItem;
|
|
// Cast returned reference into pointer
|
|
QTextItem* sigval2 = const_cast<QTextItem*>(&textItem_ret);
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawTextItem(this, handle__DrawTextItem, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawTextItem(QPointF* p, QTextItem* textItem) {
|
|
|
|
QPaintEngine::drawTextItem(*p, *textItem);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawTiledPixmap = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawTiledPixmap(const QRectF& r, const QPixmap& pixmap, const QPointF& s) override {
|
|
if (handle__DrawTiledPixmap == 0) {
|
|
QPaintEngine::drawTiledPixmap(r, pixmap, s);
|
|
return;
|
|
}
|
|
|
|
const QRectF& r_ret = r;
|
|
// Cast returned reference into pointer
|
|
QRectF* sigval1 = const_cast<QRectF*>(&r_ret);
|
|
const QPixmap& pixmap_ret = pixmap;
|
|
// Cast returned reference into pointer
|
|
QPixmap* sigval2 = const_cast<QPixmap*>(&pixmap_ret);
|
|
const QPointF& s_ret = s;
|
|
// Cast returned reference into pointer
|
|
QPointF* sigval3 = const_cast<QPointF*>(&s_ret);
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawTiledPixmap(this, handle__DrawTiledPixmap, sigval1, sigval2, sigval3);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawTiledPixmap(QRectF* r, QPixmap* pixmap, QPointF* s) {
|
|
|
|
QPaintEngine::drawTiledPixmap(*r, *pixmap, *s);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__DrawImage = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void drawImage(const QRectF& r, const QImage& pm, const QRectF& sr, Qt::ImageConversionFlags flags) override {
|
|
if (handle__DrawImage == 0) {
|
|
QPaintEngine::drawImage(r, pm, sr, flags);
|
|
return;
|
|
}
|
|
|
|
const QRectF& r_ret = r;
|
|
// Cast returned reference into pointer
|
|
QRectF* sigval1 = const_cast<QRectF*>(&r_ret);
|
|
const QImage& pm_ret = pm;
|
|
// Cast returned reference into pointer
|
|
QImage* sigval2 = const_cast<QImage*>(&pm_ret);
|
|
const QRectF& sr_ret = sr;
|
|
// Cast returned reference into pointer
|
|
QRectF* sigval3 = const_cast<QRectF*>(&sr_ret);
|
|
Qt::ImageConversionFlags flags_ret = flags;
|
|
int sigval4 = static_cast<int>(flags_ret);
|
|
|
|
miqt_exec_callback_QPaintEngine_DrawImage(this, handle__DrawImage, sigval1, sigval2, sigval3, sigval4);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_DrawImage(QRectF* r, QImage* pm, QRectF* sr, int flags) {
|
|
|
|
QPaintEngine::drawImage(*r, *pm, *sr, static_cast<Qt::ImageConversionFlags>(flags));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__CoordinateOffset = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QPoint coordinateOffset() const override {
|
|
if (handle__CoordinateOffset == 0) {
|
|
return QPaintEngine::coordinateOffset();
|
|
}
|
|
|
|
|
|
QPoint* callback_return_value = miqt_exec_callback_QPaintEngine_CoordinateOffset(const_cast<MiqtVirtualQPaintEngine*>(this), handle__CoordinateOffset);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
QPoint* virtualbase_CoordinateOffset() const {
|
|
|
|
return new QPoint(QPaintEngine::coordinateOffset());
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__Type = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QPaintEngine::Type type() const override {
|
|
if (handle__Type == 0) {
|
|
return (QPaintEngine::Type)(0); // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_QPaintEngine_Type(const_cast<MiqtVirtualQPaintEngine*>(this), handle__Type);
|
|
|
|
return static_cast<QPaintEngine::Type>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__CreatePixmap = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QPixmap createPixmap(QSize size) override {
|
|
if (handle__CreatePixmap == 0) {
|
|
return QPaintEngine::createPixmap(size);
|
|
}
|
|
|
|
QSize* sigval1 = new QSize(size);
|
|
|
|
QPixmap* callback_return_value = miqt_exec_callback_QPaintEngine_CreatePixmap(this, handle__CreatePixmap, sigval1);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
QPixmap* virtualbase_CreatePixmap(QSize* size) {
|
|
|
|
return new QPixmap(QPaintEngine::createPixmap(*size));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__CreatePixmapFromImage = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QPixmap createPixmapFromImage(QImage image, Qt::ImageConversionFlags flags) override {
|
|
if (handle__CreatePixmapFromImage == 0) {
|
|
return QPaintEngine::createPixmapFromImage(image, flags);
|
|
}
|
|
|
|
QImage* sigval1 = new QImage(image);
|
|
Qt::ImageConversionFlags flags_ret = flags;
|
|
int sigval2 = static_cast<int>(flags_ret);
|
|
|
|
QPixmap* callback_return_value = miqt_exec_callback_QPaintEngine_CreatePixmapFromImage(this, handle__CreatePixmapFromImage, sigval1, sigval2);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
QPixmap* virtualbase_CreatePixmapFromImage(QImage* image, int flags) {
|
|
|
|
return new QPixmap(QPaintEngine::createPixmapFromImage(*image, static_cast<Qt::ImageConversionFlags>(flags)));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
QPaintEngine* QPaintEngine_new() {
|
|
return new MiqtVirtualQPaintEngine();
|
|
}
|
|
|
|
QPaintEngine* QPaintEngine_new2(int features) {
|
|
return new MiqtVirtualQPaintEngine(static_cast<QPaintEngine::PaintEngineFeatures>(features));
|
|
}
|
|
|
|
bool QPaintEngine_IsActive(const QPaintEngine* self) {
|
|
return self->isActive();
|
|
}
|
|
|
|
void QPaintEngine_SetActive(QPaintEngine* self, bool newState) {
|
|
self->setActive(newState);
|
|
}
|
|
|
|
bool QPaintEngine_Begin(QPaintEngine* self, QPaintDevice* pdev) {
|
|
return self->begin(pdev);
|
|
}
|
|
|
|
bool QPaintEngine_End(QPaintEngine* self) {
|
|
return self->end();
|
|
}
|
|
|
|
void QPaintEngine_UpdateState(QPaintEngine* self, QPaintEngineState* state) {
|
|
self->updateState(*state);
|
|
}
|
|
|
|
void QPaintEngine_DrawRects(QPaintEngine* self, QRect* rects, int rectCount) {
|
|
self->drawRects(rects, static_cast<int>(rectCount));
|
|
}
|
|
|
|
void QPaintEngine_DrawRects2(QPaintEngine* self, QRectF* rects, int rectCount) {
|
|
self->drawRects(rects, static_cast<int>(rectCount));
|
|
}
|
|
|
|
void QPaintEngine_DrawLines(QPaintEngine* self, QLine* lines, int lineCount) {
|
|
self->drawLines(lines, static_cast<int>(lineCount));
|
|
}
|
|
|
|
void QPaintEngine_DrawLines2(QPaintEngine* self, QLineF* lines, int lineCount) {
|
|
self->drawLines(lines, static_cast<int>(lineCount));
|
|
}
|
|
|
|
void QPaintEngine_DrawEllipse(QPaintEngine* self, QRectF* r) {
|
|
self->drawEllipse(*r);
|
|
}
|
|
|
|
void QPaintEngine_DrawEllipseWithQRect(QPaintEngine* self, QRect* r) {
|
|
self->drawEllipse(*r);
|
|
}
|
|
|
|
void QPaintEngine_DrawPath(QPaintEngine* self, QPainterPath* path) {
|
|
self->drawPath(*path);
|
|
}
|
|
|
|
void QPaintEngine_DrawPoints(QPaintEngine* self, QPointF* points, int pointCount) {
|
|
self->drawPoints(points, static_cast<int>(pointCount));
|
|
}
|
|
|
|
void QPaintEngine_DrawPoints2(QPaintEngine* self, QPoint* points, int pointCount) {
|
|
self->drawPoints(points, static_cast<int>(pointCount));
|
|
}
|
|
|
|
void QPaintEngine_DrawPolygon(QPaintEngine* self, QPointF* points, int pointCount, int mode) {
|
|
self->drawPolygon(points, static_cast<int>(pointCount), static_cast<QPaintEngine::PolygonDrawMode>(mode));
|
|
}
|
|
|
|
void QPaintEngine_DrawPolygon2(QPaintEngine* self, QPoint* points, int pointCount, int mode) {
|
|
self->drawPolygon(points, static_cast<int>(pointCount), static_cast<QPaintEngine::PolygonDrawMode>(mode));
|
|
}
|
|
|
|
void QPaintEngine_DrawPixmap(QPaintEngine* self, QRectF* r, QPixmap* pm, QRectF* sr) {
|
|
self->drawPixmap(*r, *pm, *sr);
|
|
}
|
|
|
|
void QPaintEngine_DrawTextItem(QPaintEngine* self, QPointF* p, QTextItem* textItem) {
|
|
self->drawTextItem(*p, *textItem);
|
|
}
|
|
|
|
void QPaintEngine_DrawTiledPixmap(QPaintEngine* self, QRectF* r, QPixmap* pixmap, QPointF* s) {
|
|
self->drawTiledPixmap(*r, *pixmap, *s);
|
|
}
|
|
|
|
void QPaintEngine_DrawImage(QPaintEngine* self, QRectF* r, QImage* pm, QRectF* sr, int flags) {
|
|
self->drawImage(*r, *pm, *sr, static_cast<Qt::ImageConversionFlags>(flags));
|
|
}
|
|
|
|
void QPaintEngine_SetPaintDevice(QPaintEngine* self, QPaintDevice* device) {
|
|
self->setPaintDevice(device);
|
|
}
|
|
|
|
QPaintDevice* QPaintEngine_PaintDevice(const QPaintEngine* self) {
|
|
return self->paintDevice();
|
|
}
|
|
|
|
void QPaintEngine_SetSystemClip(QPaintEngine* self, QRegion* baseClip) {
|
|
self->setSystemClip(*baseClip);
|
|
}
|
|
|
|
QRegion* QPaintEngine_SystemClip(const QPaintEngine* self) {
|
|
return new QRegion(self->systemClip());
|
|
}
|
|
|
|
void QPaintEngine_SetSystemRect(QPaintEngine* self, QRect* rect) {
|
|
self->setSystemRect(*rect);
|
|
}
|
|
|
|
QRect* QPaintEngine_SystemRect(const QPaintEngine* self) {
|
|
return new QRect(self->systemRect());
|
|
}
|
|
|
|
QPoint* QPaintEngine_CoordinateOffset(const QPaintEngine* self) {
|
|
return new QPoint(self->coordinateOffset());
|
|
}
|
|
|
|
int QPaintEngine_Type(const QPaintEngine* self) {
|
|
QPaintEngine::Type _ret = self->type();
|
|
return static_cast<int>(_ret);
|
|
}
|
|
|
|
void QPaintEngine_FixNegRect(QPaintEngine* self, int* x, int* y, int* w, int* h) {
|
|
self->fix_neg_rect(static_cast<int*>(x), static_cast<int*>(y), static_cast<int*>(w), static_cast<int*>(h));
|
|
}
|
|
|
|
bool QPaintEngine_TestDirty(QPaintEngine* self, int df) {
|
|
return self->testDirty(static_cast<QPaintEngine::DirtyFlags>(df));
|
|
}
|
|
|
|
void QPaintEngine_SetDirty(QPaintEngine* self, int df) {
|
|
self->setDirty(static_cast<QPaintEngine::DirtyFlags>(df));
|
|
}
|
|
|
|
void QPaintEngine_ClearDirty(QPaintEngine* self, int df) {
|
|
self->clearDirty(static_cast<QPaintEngine::DirtyFlags>(df));
|
|
}
|
|
|
|
bool QPaintEngine_HasFeature(const QPaintEngine* self, int feature) {
|
|
return self->hasFeature(static_cast<QPaintEngine::PaintEngineFeatures>(feature));
|
|
}
|
|
|
|
QPainter* QPaintEngine_Painter(const QPaintEngine* self) {
|
|
return self->painter();
|
|
}
|
|
|
|
void QPaintEngine_SyncState(QPaintEngine* self) {
|
|
self->syncState();
|
|
}
|
|
|
|
bool QPaintEngine_IsExtended(const QPaintEngine* self) {
|
|
return self->isExtended();
|
|
}
|
|
|
|
QPixmap* QPaintEngine_CreatePixmap(QPaintEngine* self, QSize* size) {
|
|
return new QPixmap(self->createPixmap(*size));
|
|
}
|
|
|
|
QPixmap* QPaintEngine_CreatePixmapFromImage(QPaintEngine* self, QImage* image, int flags) {
|
|
return new QPixmap(self->createPixmapFromImage(*image, static_cast<Qt::ImageConversionFlags>(flags)));
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_Begin(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__Begin = slot;
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_End(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__End = slot;
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_UpdateState(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__UpdateState = slot;
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawRects(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawRects = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawRects(void* self, QRect* rects, int rectCount) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawRects(rects, rectCount);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawRects2(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawRects2 = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawRects2(void* self, QRectF* rects, int rectCount) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawRects2(rects, rectCount);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawLines(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawLines = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawLines(void* self, QLine* lines, int lineCount) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawLines(lines, lineCount);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawLines2(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawLines2 = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawLines2(void* self, QLineF* lines, int lineCount) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawLines2(lines, lineCount);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawEllipse(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawEllipse = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawEllipse(void* self, QRectF* r) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawEllipse(r);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawEllipseWithQRect(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawEllipseWithQRect = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawEllipseWithQRect(void* self, QRect* r) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawEllipseWithQRect(r);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawPath(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawPath = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawPath(void* self, QPainterPath* path) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawPath(path);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawPoints(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawPoints = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawPoints(void* self, QPointF* points, int pointCount) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawPoints(points, pointCount);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawPoints2(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawPoints2 = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawPoints2(void* self, QPoint* points, int pointCount) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawPoints2(points, pointCount);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawPolygon(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawPolygon = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawPolygon(void* self, QPointF* points, int pointCount, int mode) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawPolygon(points, pointCount, mode);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawPolygon2(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawPolygon2 = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawPolygon2(void* self, QPoint* points, int pointCount, int mode) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawPolygon2(points, pointCount, mode);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawPixmap(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawPixmap = slot;
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawTextItem(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawTextItem = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawTextItem(void* self, QPointF* p, QTextItem* textItem) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawTextItem(p, textItem);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawTiledPixmap(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawTiledPixmap = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawTiledPixmap(void* self, QRectF* r, QPixmap* pixmap, QPointF* s) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawTiledPixmap(r, pixmap, s);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_DrawImage(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__DrawImage = slot;
|
|
}
|
|
|
|
void QPaintEngine_virtualbase_DrawImage(void* self, QRectF* r, QImage* pm, QRectF* sr, int flags) {
|
|
( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_DrawImage(r, pm, sr, flags);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_CoordinateOffset(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__CoordinateOffset = slot;
|
|
}
|
|
|
|
QPoint* QPaintEngine_virtualbase_CoordinateOffset(const void* self) {
|
|
return ( (const MiqtVirtualQPaintEngine*)(self) )->virtualbase_CoordinateOffset();
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_Type(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__Type = slot;
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_CreatePixmap(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__CreatePixmap = slot;
|
|
}
|
|
|
|
QPixmap* QPaintEngine_virtualbase_CreatePixmap(void* self, QSize* size) {
|
|
return ( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_CreatePixmap(size);
|
|
}
|
|
|
|
void QPaintEngine_override_virtual_CreatePixmapFromImage(void* self, intptr_t slot) {
|
|
dynamic_cast<MiqtVirtualQPaintEngine*>( (QPaintEngine*)(self) )->handle__CreatePixmapFromImage = slot;
|
|
}
|
|
|
|
QPixmap* QPaintEngine_virtualbase_CreatePixmapFromImage(void* self, QImage* image, int flags) {
|
|
return ( (MiqtVirtualQPaintEngine*)(self) )->virtualbase_CreatePixmapFromImage(image, flags);
|
|
}
|
|
|
|
void QPaintEngine_Delete(QPaintEngine* self, bool isSubclass) {
|
|
if (isSubclass) {
|
|
delete dynamic_cast<MiqtVirtualQPaintEngine*>( self );
|
|
} else {
|
|
delete self;
|
|
}
|
|
}
|
|
|
|
int QPaintEngineState_State(const QPaintEngineState* self) {
|
|
QPaintEngine::DirtyFlags _ret = self->state();
|
|
return static_cast<int>(_ret);
|
|
}
|
|
|
|
QPen* QPaintEngineState_Pen(const QPaintEngineState* self) {
|
|
return new QPen(self->pen());
|
|
}
|
|
|
|
QBrush* QPaintEngineState_Brush(const QPaintEngineState* self) {
|
|
return new QBrush(self->brush());
|
|
}
|
|
|
|
QPointF* QPaintEngineState_BrushOrigin(const QPaintEngineState* self) {
|
|
return new QPointF(self->brushOrigin());
|
|
}
|
|
|
|
QBrush* QPaintEngineState_BackgroundBrush(const QPaintEngineState* self) {
|
|
return new QBrush(self->backgroundBrush());
|
|
}
|
|
|
|
int QPaintEngineState_BackgroundMode(const QPaintEngineState* self) {
|
|
Qt::BGMode _ret = self->backgroundMode();
|
|
return static_cast<int>(_ret);
|
|
}
|
|
|
|
QFont* QPaintEngineState_Font(const QPaintEngineState* self) {
|
|
return new QFont(self->font());
|
|
}
|
|
|
|
QTransform* QPaintEngineState_Transform(const QPaintEngineState* self) {
|
|
return new QTransform(self->transform());
|
|
}
|
|
|
|
int QPaintEngineState_ClipOperation(const QPaintEngineState* self) {
|
|
Qt::ClipOperation _ret = self->clipOperation();
|
|
return static_cast<int>(_ret);
|
|
}
|
|
|
|
QRegion* QPaintEngineState_ClipRegion(const QPaintEngineState* self) {
|
|
return new QRegion(self->clipRegion());
|
|
}
|
|
|
|
QPainterPath* QPaintEngineState_ClipPath(const QPaintEngineState* self) {
|
|
return new QPainterPath(self->clipPath());
|
|
}
|
|
|
|
bool QPaintEngineState_IsClipEnabled(const QPaintEngineState* self) {
|
|
return self->isClipEnabled();
|
|
}
|
|
|
|
int QPaintEngineState_RenderHints(const QPaintEngineState* self) {
|
|
QPainter::RenderHints _ret = self->renderHints();
|
|
return static_cast<int>(_ret);
|
|
}
|
|
|
|
int QPaintEngineState_CompositionMode(const QPaintEngineState* self) {
|
|
QPainter::CompositionMode _ret = self->compositionMode();
|
|
return static_cast<int>(_ret);
|
|
}
|
|
|
|
double QPaintEngineState_Opacity(const QPaintEngineState* self) {
|
|
qreal _ret = self->opacity();
|
|
return static_cast<double>(_ret);
|
|
}
|
|
|
|
QPainter* QPaintEngineState_Painter(const QPaintEngineState* self) {
|
|
return self->painter();
|
|
}
|
|
|
|
bool QPaintEngineState_BrushNeedsResolving(const QPaintEngineState* self) {
|
|
return self->brushNeedsResolving();
|
|
}
|
|
|
|
bool QPaintEngineState_PenNeedsResolving(const QPaintEngineState* self) {
|
|
return self->penNeedsResolving();
|
|
}
|
|
|
|
void QPaintEngineState_Delete(QPaintEngineState* self, bool isSubclass) {
|
|
if (isSubclass) {
|
|
delete dynamic_cast<QPaintEngineState*>( self );
|
|
} else {
|
|
delete self;
|
|
}
|
|
}
|
|
|