cutego/gui/gui.cpp

// +build !minimal

#define protected public
#define private public

#include "gui.h"
#include "_cgo_export.h"

#include <QAbstractItemModel>
#include <QAbstractTextDocumentLayout>
#include <QAccessible>
#include <QAccessibleActionInterface>
#include <QAccessibleEditableTextInterface>
#include <QAccessibleEvent>
#include <QAccessibleInterface>
#include <QAccessibleObject>
#include <QAccessiblePlugin>
#include <QAccessibleStateChangeEvent>
#include <QAccessibleTableCellInterface>
#include <QAccessibleTableInterface>
#include <QAccessibleTableModelChangeEvent>
#include <QAccessibleTextCursorEvent>
#include <QAccessibleTextInsertEvent>
#include <QAccessibleTextInterface>
#include <QAccessibleTextRemoveEvent>
#include <QAccessibleTextSelectionEvent>
#include <QAccessibleTextUpdateEvent>
#include <QAccessibleValueChangeEvent>
#include <QAccessibleValueInterface>
#include <QAction>
#include <QActionEvent>
#include <QBackingStore>
#include <QBitmap>
#include <QBrush>
#include <QByteArray>
#include <QChar>
#include <QChildEvent>
#include <QClipboard>
#include <QCloseEvent>
#include <QColor>
#include <QConicalGradient>
#include <QContextMenuEvent>
#include <QCursor>
#include <QDataStream>
#include <QDesktopServices>
#include <QDoubleValidator>
#include <QDrag>
#include <QDragEnterEvent>
#include <QDragLeaveEvent>
#include <QDragMoveEvent>
#include <QDropEvent>
#include <QEnterEvent>
#include <QEvent>
#include <QExposeEvent>
#include <QFile>
#include <QFileOpenEvent>
#include <QFocusEvent>
#include <QFont>
#include <QFontDatabase>
#include <QFontInfo>
#include <QFontMetrics>
#include <QFontMetricsF>
#include <QGenericPlugin>
#include <QGenericPluginFactory>
#include <QGlyphRun>
#include <QGradient>
#include <QGuiApplication>
#include <QHash>
#include <QHelpEvent>
#include <QHideEvent>
#include <QHoverEvent>
#include <QIODevice>
#include <QIcon>
#include <QIconDragEvent>
#include <QIconEngine>
#include <QIconEnginePlugin>
#include <QImage>
#include <QImageIOHandler>
#include <QImageIOPlugin>
#include <QImageReader>
#include <QImageWriter>
#include <QInputEvent>
#include <QInputMethod>
#include <QInputMethodEvent>
#include <QInputMethodQueryEvent>
#include <QIntValidator>
#include <QKeyEvent>
#include <QKeySequence>
#include <QLatin1String>
#include <QLine>
#include <QLineF>
#include <QLinearGradient>
#include <QList>
#include <QLocale>
#include <QMap>
#include <QMargins>
#include <QMarginsF>
#include <QMatrix4x4>
#include <QMetaMethod>
#include <QMetaObject>
#include <QMimeData>
#include <QModelIndex>
#include <QMouseEvent>
#include <QMoveEvent>
#include <QMovie>
#include <QNativeGestureEvent>
#include <QObject>
#include <QOffscreenSurface>
#include <QPageLayout>
#include <QPageSize>
#include <QPagedPaintDevice>
#include <QPaintDevice>
#include <QPaintDeviceWindow>
#include <QPaintEngine>
#include <QPaintEngineState>
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
#include <QPainterPathStroker>
#include <QPalette>
#include <QPdfWriter>
#include <QPen>
#include <QPersistentModelIndex>
#include <QPicture>
#include <QPixelFormat>
#include <QPixmap>
#include <QPixmapCache>
#include <QPlatformSurfaceEvent>
#include <QPoint>
#include <QPointF>
#include <QPointingDeviceUniqueId>
#include <QPolygon>
#include <QPolygonF>
#include <QQuaternion>
#include <QRadialGradient>
#include <QRasterWindow>
#include <QRawFont>
#include <QRect>
#include <QRectF>
#include <QRegExp>
#include <QRegExpValidator>
#include <QRegion>
#include <QRegularExpression>
#include <QRegularExpressionValidator>
#include <QResizeEvent>
#include <QRgba64>
#include <QScreen>
#include <QScrollEvent>
#include <QScrollPrepareEvent>
#include <QSessionManager>
#include <QShortcut>
#include <QShortcutEvent>
#include <QShowEvent>
#include <QSize>
#include <QSizeF>
#include <QStandardItem>
#include <QStandardItemModel>
#include <QStaticText>
#include <QStatusTipEvent>
#include <QString>
#include <QStringList>
#include <QStyle>
#include <QStyleHints>
#include <QSurface>
#include <QSurfaceFormat>
#include <QSyntaxHighlighter>
#include <QTabletEvent>
#include <QTextBlock>
#include <QTextBlockFormat>
#include <QTextBlockGroup>
#include <QTextBlockUserData>
#include <QTextCharFormat>
#include <QTextCodec>
#include <QTextCursor>
#include <QTextDocument>
#include <QTextDocumentFragment>
#include <QTextDocumentWriter>
#include <QTextFormat>
#include <QTextFragment>
#include <QTextFrame>
#include <QTextFrameFormat>
#include <QTextImageFormat>
#include <QTextInlineObject>
#include <QTextItem>
#include <QTextLayout>
#include <QTextLength>
#include <QTextLine>
#include <QTextList>
#include <QTextListFormat>
#include <QTextObject>
#include <QTextObjectInterface>
#include <QTextOption>
#include <QTextTable>
#include <QTextTableCell>
#include <QTextTableCellFormat>
#include <QTextTableFormat>
#include <QTime>
#include <QTimer>
#include <QTimerEvent>
#include <QTouchDevice>
#include <QTouchEvent>
#include <QTransform>
#include <QUrl>
#include <QValidator>
#include <QVariant>
#include <QVector>
#include <QVector2D>
#include <QVector3D>
#include <QVector4D>
#include <QWhatsThis>
#include <QWhatsThisClickedEvent>
#include <QWheelEvent>
#include <QWindow>
#include <QWindowStateChangeEvent>

void* PaintContext_NewPaintContext()
{
	return new QAbstractTextDocumentLayout::PaintContext();
}

void* PaintContext_Clip(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->clip; new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void PaintContext_SetClip(void* ptr, void* vqr)
{
	static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->clip = *static_cast<QRectF*>(vqr);
}

int PaintContext_CursorPosition(void* ptr)
{
	return static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->cursorPosition;
}

void PaintContext_SetCursorPosition(void* ptr, int vin)
{
	static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->cursorPosition = vin;
}

void* PaintContext_Palette(void* ptr)
{
	return new QPalette(static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->palette);
}

void PaintContext_SetPalette(void* ptr, void* vqp)
{
	static_cast<QAbstractTextDocumentLayout::PaintContext*>(ptr)->palette = *static_cast<QPalette*>(vqp);
}

class MyQAbstractTextDocumentLayout: public QAbstractTextDocumentLayout
{
public:
	MyQAbstractTextDocumentLayout(QTextDocument *document) : QAbstractTextDocumentLayout(document) {};
	void documentChanged(int position, int charsRemoved, int charsAdded) { callbackQAbstractTextDocumentLayout_DocumentChanged(this, position, charsRemoved, charsAdded); };
	void Signal_DocumentSizeChanged(const QSizeF & newSize) { callbackQAbstractTextDocumentLayout_DocumentSizeChanged(this, const_cast<QSizeF*>(&newSize)); };
	void draw(QPainter * painter, const PaintContext & context) { callbackQAbstractTextDocumentLayout_Draw(this, painter, const_cast<PaintContext*>(&context)); };
	
	void Signal_PageCountChanged(int newPages) { callbackQAbstractTextDocumentLayout_PageCountChanged(this, newPages); };
	
	
	void Signal_Update(const QRectF & rect) { callbackQAbstractTextDocumentLayout_Update(this, const_cast<QRectF*>(&rect)); };
	void Signal_UpdateBlock(const QTextBlock & block) { callbackQAbstractTextDocumentLayout_UpdateBlock(this, const_cast<QTextBlock*>(&block)); };
	QRectF blockBoundingRect(const QTextBlock & block) const { return *static_cast<QRectF*>(callbackQAbstractTextDocumentLayout_BlockBoundingRect(const_cast<void*>(static_cast<const void*>(this)), const_cast<QTextBlock*>(&block))); };
	QRectF frameBoundingRect(QTextFrame * frame) const { return *static_cast<QRectF*>(callbackQAbstractTextDocumentLayout_FrameBoundingRect(const_cast<void*>(static_cast<const void*>(this)), frame)); };
	QSizeF documentSize() const { return *static_cast<QSizeF*>(callbackQAbstractTextDocumentLayout_DocumentSize(const_cast<void*>(static_cast<const void*>(this)))); };
	int hitTest(const QPointF & point, Qt::HitTestAccuracy accuracy) const { return callbackQAbstractTextDocumentLayout_HitTest(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPointF*>(&point), accuracy); };
	int pageCount() const { return callbackQAbstractTextDocumentLayout_PageCount(const_cast<void*>(static_cast<const void*>(this))); };
	bool event(QEvent * e) { return callbackQAbstractTextDocumentLayout_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractTextDocumentLayout_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQAbstractTextDocumentLayout_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAbstractTextDocumentLayout_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAbstractTextDocumentLayout_CustomEvent(this, event); };
	void deleteLater() { callbackQAbstractTextDocumentLayout_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAbstractTextDocumentLayout_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractTextDocumentLayout_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQAbstractTextDocumentLayout_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAbstractTextDocumentLayout_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractTextDocumentLayout_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAbstractTextDocumentLayout_Format(void* ptr, int position)
{
	return new QTextCharFormat(static_cast<QAbstractTextDocumentLayout*>(ptr)->format(position));
}

void* QAbstractTextDocumentLayout_NewQAbstractTextDocumentLayout(void* document)
{
	return new MyQAbstractTextDocumentLayout(static_cast<QTextDocument*>(document));
}

void QAbstractTextDocumentLayout_DocumentChanged(void* ptr, int position, int charsRemoved, int charsAdded)
{
	static_cast<QAbstractTextDocumentLayout*>(ptr)->documentChanged(position, charsRemoved, charsAdded);
}

void QAbstractTextDocumentLayout_ConnectDocumentSizeChanged(void* ptr)
{
	QObject::connect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QSizeF &)>(&QAbstractTextDocumentLayout::documentSizeChanged), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QSizeF &)>(&MyQAbstractTextDocumentLayout::Signal_DocumentSizeChanged));
}

void QAbstractTextDocumentLayout_DisconnectDocumentSizeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QSizeF &)>(&QAbstractTextDocumentLayout::documentSizeChanged), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QSizeF &)>(&MyQAbstractTextDocumentLayout::Signal_DocumentSizeChanged));
}

void QAbstractTextDocumentLayout_DocumentSizeChanged(void* ptr, void* newSize)
{
	static_cast<QAbstractTextDocumentLayout*>(ptr)->documentSizeChanged(*static_cast<QSizeF*>(newSize));
}

void QAbstractTextDocumentLayout_Draw(void* ptr, void* painter, void* context)
{
	static_cast<QAbstractTextDocumentLayout*>(ptr)->draw(static_cast<QPainter*>(painter), *static_cast<QAbstractTextDocumentLayout::PaintContext*>(context));
}

void QAbstractTextDocumentLayout_DrawInlineObject(void* ptr, void* painter, void* rect, void* object, int posInDocument, void* format)
{
	static_cast<QAbstractTextDocumentLayout*>(ptr)->drawInlineObject(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect), *static_cast<QTextInlineObject*>(object), posInDocument, *static_cast<QTextFormat*>(format));
}

void QAbstractTextDocumentLayout_DrawInlineObjectDefault(void* ptr, void* painter, void* rect, void* object, int posInDocument, void* format)
{
		static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::drawInlineObject(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect), *static_cast<QTextInlineObject*>(object), posInDocument, *static_cast<QTextFormat*>(format));
}

void QAbstractTextDocumentLayout_ConnectPageCountChanged(void* ptr)
{
	QObject::connect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(int)>(&QAbstractTextDocumentLayout::pageCountChanged), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(int)>(&MyQAbstractTextDocumentLayout::Signal_PageCountChanged));
}

void QAbstractTextDocumentLayout_DisconnectPageCountChanged(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(int)>(&QAbstractTextDocumentLayout::pageCountChanged), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(int)>(&MyQAbstractTextDocumentLayout::Signal_PageCountChanged));
}

void QAbstractTextDocumentLayout_PageCountChanged(void* ptr, int newPages)
{
	static_cast<QAbstractTextDocumentLayout*>(ptr)->pageCountChanged(newPages);
}

void QAbstractTextDocumentLayout_PositionInlineObject(void* ptr, void* item, int posInDocument, void* format)
{
	static_cast<QAbstractTextDocumentLayout*>(ptr)->positionInlineObject(*static_cast<QTextInlineObject*>(item), posInDocument, *static_cast<QTextFormat*>(format));
}

void QAbstractTextDocumentLayout_PositionInlineObjectDefault(void* ptr, void* item, int posInDocument, void* format)
{
		static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::positionInlineObject(*static_cast<QTextInlineObject*>(item), posInDocument, *static_cast<QTextFormat*>(format));
}

void QAbstractTextDocumentLayout_RegisterHandler(void* ptr, int objectType, void* component)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(component))) {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->registerHandler(objectType, static_cast<QOffscreenSurface*>(component));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(component))) {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->registerHandler(objectType, static_cast<QPaintDeviceWindow*>(component));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(component))) {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->registerHandler(objectType, static_cast<QPdfWriter*>(component));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(component))) {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->registerHandler(objectType, static_cast<QWindow*>(component));
	} else {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->registerHandler(objectType, static_cast<QObject*>(component));
	}
}

void QAbstractTextDocumentLayout_ResizeInlineObject(void* ptr, void* item, int posInDocument, void* format)
{
	static_cast<QAbstractTextDocumentLayout*>(ptr)->resizeInlineObject(*static_cast<QTextInlineObject*>(item), posInDocument, *static_cast<QTextFormat*>(format));
}

void QAbstractTextDocumentLayout_ResizeInlineObjectDefault(void* ptr, void* item, int posInDocument, void* format)
{
		static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::resizeInlineObject(*static_cast<QTextInlineObject*>(item), posInDocument, *static_cast<QTextFormat*>(format));
}

void QAbstractTextDocumentLayout_SetPaintDevice(void* ptr, void* device)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(device))) {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->setPaintDevice(static_cast<QPaintDeviceWindow*>(device));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(device))) {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->setPaintDevice(static_cast<QPdfWriter*>(device));
	} else {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->setPaintDevice(static_cast<QPaintDevice*>(device));
	}
}

void QAbstractTextDocumentLayout_UnregisterHandler(void* ptr, int objectType, void* component)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(component))) {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->unregisterHandler(objectType, static_cast<QOffscreenSurface*>(component));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(component))) {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->unregisterHandler(objectType, static_cast<QPaintDeviceWindow*>(component));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(component))) {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->unregisterHandler(objectType, static_cast<QPdfWriter*>(component));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(component))) {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->unregisterHandler(objectType, static_cast<QWindow*>(component));
	} else {
		static_cast<QAbstractTextDocumentLayout*>(ptr)->unregisterHandler(objectType, static_cast<QObject*>(component));
	}
}

void QAbstractTextDocumentLayout_ConnectUpdate(void* ptr)
{
	QObject::connect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QRectF &)>(&QAbstractTextDocumentLayout::update), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QRectF &)>(&MyQAbstractTextDocumentLayout::Signal_Update));
}

void QAbstractTextDocumentLayout_DisconnectUpdate(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QRectF &)>(&QAbstractTextDocumentLayout::update), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QRectF &)>(&MyQAbstractTextDocumentLayout::Signal_Update));
}

void QAbstractTextDocumentLayout_Update(void* ptr, void* rect)
{
	static_cast<QAbstractTextDocumentLayout*>(ptr)->update(*static_cast<QRectF*>(rect));
}

void QAbstractTextDocumentLayout_ConnectUpdateBlock(void* ptr)
{
	QObject::connect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QTextBlock &)>(&QAbstractTextDocumentLayout::updateBlock), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QTextBlock &)>(&MyQAbstractTextDocumentLayout::Signal_UpdateBlock));
}

void QAbstractTextDocumentLayout_DisconnectUpdateBlock(void* ptr)
{
	QObject::disconnect(static_cast<QAbstractTextDocumentLayout*>(ptr), static_cast<void (QAbstractTextDocumentLayout::*)(const QTextBlock &)>(&QAbstractTextDocumentLayout::updateBlock), static_cast<MyQAbstractTextDocumentLayout*>(ptr), static_cast<void (MyQAbstractTextDocumentLayout::*)(const QTextBlock &)>(&MyQAbstractTextDocumentLayout::Signal_UpdateBlock));
}

void QAbstractTextDocumentLayout_UpdateBlock(void* ptr, void* block)
{
	static_cast<QAbstractTextDocumentLayout*>(ptr)->updateBlock(*static_cast<QTextBlock*>(block));
}

void* QAbstractTextDocumentLayout_PaintDevice(void* ptr)
{
	return static_cast<QAbstractTextDocumentLayout*>(ptr)->paintDevice();
}

void* QAbstractTextDocumentLayout_BlockBoundingRect(void* ptr, void* block)
{
	return ({ QRectF tmpValue = static_cast<QAbstractTextDocumentLayout*>(ptr)->blockBoundingRect(*static_cast<QTextBlock*>(block)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QAbstractTextDocumentLayout_FrameBoundingRect(void* ptr, void* frame)
{
	return ({ QRectF tmpValue = static_cast<QAbstractTextDocumentLayout*>(ptr)->frameBoundingRect(static_cast<QTextFrame*>(frame)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QAbstractTextDocumentLayout_DocumentSize(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QAbstractTextDocumentLayout*>(ptr)->documentSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QAbstractTextDocumentLayout_AnchorAt(void* ptr, void* position)
{
	return ({ QByteArray t81dfdf = static_cast<QAbstractTextDocumentLayout*>(ptr)->anchorAt(*static_cast<QPointF*>(position)).toUtf8(); QtGui_PackedString { const_cast<char*>(t81dfdf.prepend("WHITESPACE").constData()+10), t81dfdf.size()-10 }; });
}

struct QtGui_PackedString QAbstractTextDocumentLayout_ImageAt(void* ptr, void* pos)
{
	return ({ QByteArray t0eaa79 = static_cast<QAbstractTextDocumentLayout*>(ptr)->imageAt(*static_cast<QPointF*>(pos)).toUtf8(); QtGui_PackedString { const_cast<char*>(t0eaa79.prepend("WHITESPACE").constData()+10), t0eaa79.size()-10 }; });
}

void* QAbstractTextDocumentLayout_Document(void* ptr)
{
	return static_cast<QAbstractTextDocumentLayout*>(ptr)->document();
}

void* QAbstractTextDocumentLayout_FormatAt(void* ptr, void* pos)
{
	return new QTextFormat(static_cast<QAbstractTextDocumentLayout*>(ptr)->formatAt(*static_cast<QPointF*>(pos)));
}

void* QAbstractTextDocumentLayout_HandlerForObject(void* ptr, int objectType)
{
	return static_cast<QAbstractTextDocumentLayout*>(ptr)->handlerForObject(objectType);
}

int QAbstractTextDocumentLayout_HitTest(void* ptr, void* point, long long accuracy)
{
	return static_cast<QAbstractTextDocumentLayout*>(ptr)->hitTest(*static_cast<QPointF*>(point), static_cast<Qt::HitTestAccuracy>(accuracy));
}

int QAbstractTextDocumentLayout_PageCount(void* ptr)
{
	return static_cast<QAbstractTextDocumentLayout*>(ptr)->pageCount();
}

void* QAbstractTextDocumentLayout___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QAbstractTextDocumentLayout___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAbstractTextDocumentLayout___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QAbstractTextDocumentLayout___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAbstractTextDocumentLayout___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractTextDocumentLayout___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QAbstractTextDocumentLayout___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAbstractTextDocumentLayout___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractTextDocumentLayout___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QAbstractTextDocumentLayout___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAbstractTextDocumentLayout___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractTextDocumentLayout___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QAbstractTextDocumentLayout___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QAbstractTextDocumentLayout___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAbstractTextDocumentLayout___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QAbstractTextDocumentLayout_EventDefault(void* ptr, void* e)
{
		return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::event(static_cast<QEvent*>(e));
}

char QAbstractTextDocumentLayout_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QAbstractTextDocumentLayout_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::childEvent(static_cast<QChildEvent*>(event));
}

void QAbstractTextDocumentLayout_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAbstractTextDocumentLayout_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::customEvent(static_cast<QEvent*>(event));
}

void QAbstractTextDocumentLayout_DeleteLaterDefault(void* ptr)
{
		static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::deleteLater();
}

void QAbstractTextDocumentLayout_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAbstractTextDocumentLayout_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QAbstractTextDocumentLayout_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAbstractTextDocumentLayout*>(ptr)->QAbstractTextDocumentLayout::metaObject());
}

int QAccessible_InvalidEvent_Type()
{
	return QAccessible::InvalidEvent;
}

void* QAccessible_QAccessible_QueryAccessibleInterface(void* object)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
		return QAccessible::queryAccessibleInterface(static_cast<QOffscreenSurface*>(object));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
		return QAccessible::queryAccessibleInterface(static_cast<QPaintDeviceWindow*>(object));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
		return QAccessible::queryAccessibleInterface(static_cast<QPdfWriter*>(object));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
		return QAccessible::queryAccessibleInterface(static_cast<QWindow*>(object));
	} else {
		return QAccessible::queryAccessibleInterface(static_cast<QObject*>(object));
	}
}

char QAccessible_QAccessible_IsActive()
{
	return QAccessible::isActive();
}

void QAccessible_QAccessible_SetRootObject(void* object)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
		QAccessible::setRootObject(static_cast<QOffscreenSurface*>(object));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
		QAccessible::setRootObject(static_cast<QPaintDeviceWindow*>(object));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
		QAccessible::setRootObject(static_cast<QPdfWriter*>(object));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
		QAccessible::setRootObject(static_cast<QWindow*>(object));
	} else {
		QAccessible::setRootObject(static_cast<QObject*>(object));
	}
}

void QAccessible_QAccessible_UpdateAccessibility(void* event)
{
	QAccessible::updateAccessibility(static_cast<QAccessibleEvent*>(event));
}

class MyQAccessibleActionInterface: public QAccessibleActionInterface
{
public:
	void doAction(const QString & actionName) { QByteArray tcd1a8c = actionName.toUtf8(); QtGui_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c.prepend("WHITESPACE").constData()+10), tcd1a8c.size()-10 };callbackQAccessibleActionInterface_DoAction(this, actionNamePacked); };
	 ~MyQAccessibleActionInterface() { callbackQAccessibleActionInterface_DestroyQAccessibleActionInterface(this); };
	QString localizedActionDescription(const QString & actionName) const { QByteArray tcd1a8c = actionName.toUtf8(); QtGui_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c.prepend("WHITESPACE").constData()+10), tcd1a8c.size()-10 };return QString(callbackQAccessibleActionInterface_LocalizedActionDescription(const_cast<void*>(static_cast<const void*>(this)), actionNamePacked)); };
	QString localizedActionName(const QString & actionName) const { QByteArray tcd1a8c = actionName.toUtf8(); QtGui_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c.prepend("WHITESPACE").constData()+10), tcd1a8c.size()-10 };return QString(callbackQAccessibleActionInterface_LocalizedActionName(const_cast<void*>(static_cast<const void*>(this)), actionNamePacked)); };
	QStringList actionNames() const { return QString(callbackQAccessibleActionInterface_ActionNames(const_cast<void*>(static_cast<const void*>(this)))).split("|", QString::SkipEmptyParts); };
	QStringList keyBindingsForAction(const QString & actionName) const { QByteArray tcd1a8c = actionName.toUtf8(); QtGui_PackedString actionNamePacked = { const_cast<char*>(tcd1a8c.prepend("WHITESPACE").constData()+10), tcd1a8c.size()-10 };return QString(callbackQAccessibleActionInterface_KeyBindingsForAction(const_cast<void*>(static_cast<const void*>(this)), actionNamePacked)).split("|", QString::SkipEmptyParts); };
};

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_NextPageAction()
{
	return ({ QByteArray t1ad988 = QAccessibleActionInterface::nextPageAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t1ad988.prepend("WHITESPACE").constData()+10), t1ad988.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_PreviousPageAction()
{
	return ({ QByteArray t44741f = QAccessibleActionInterface::previousPageAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t44741f.prepend("WHITESPACE").constData()+10), t44741f.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ScrollDownAction()
{
	return ({ QByteArray tf765c1 = QAccessibleActionInterface::scrollDownAction().toUtf8(); QtGui_PackedString { const_cast<char*>(tf765c1.prepend("WHITESPACE").constData()+10), tf765c1.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ScrollLeftAction()
{
	return ({ QByteArray t35286b = QAccessibleActionInterface::scrollLeftAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t35286b.prepend("WHITESPACE").constData()+10), t35286b.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ScrollRightAction()
{
	return ({ QByteArray taa7ac9 = QAccessibleActionInterface::scrollRightAction().toUtf8(); QtGui_PackedString { const_cast<char*>(taa7ac9.prepend("WHITESPACE").constData()+10), taa7ac9.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ScrollUpAction()
{
	return ({ QByteArray t6e10e7 = QAccessibleActionInterface::scrollUpAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t6e10e7.prepend("WHITESPACE").constData()+10), t6e10e7.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_DecreaseAction()
{
	return ({ QByteArray t572cdb = QAccessibleActionInterface::decreaseAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t572cdb.prepend("WHITESPACE").constData()+10), t572cdb.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_IncreaseAction()
{
	return ({ QByteArray tf61c5c = QAccessibleActionInterface::increaseAction().toUtf8(); QtGui_PackedString { const_cast<char*>(tf61c5c.prepend("WHITESPACE").constData()+10), tf61c5c.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_PressAction()
{
	return ({ QByteArray t899f7e = QAccessibleActionInterface::pressAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t899f7e.prepend("WHITESPACE").constData()+10), t899f7e.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_SetFocusAction()
{
	return ({ QByteArray t8516d1 = QAccessibleActionInterface::setFocusAction().toUtf8(); QtGui_PackedString { const_cast<char*>(t8516d1.prepend("WHITESPACE").constData()+10), t8516d1.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ShowMenuAction()
{
	return ({ QByteArray tfc8b6a = QAccessibleActionInterface::showMenuAction().toUtf8(); QtGui_PackedString { const_cast<char*>(tfc8b6a.prepend("WHITESPACE").constData()+10), tfc8b6a.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_QAccessibleActionInterface_ToggleAction()
{
	return ({ QByteArray tc0e2c4 = QAccessibleActionInterface::toggleAction().toUtf8(); QtGui_PackedString { const_cast<char*>(tc0e2c4.prepend("WHITESPACE").constData()+10), tc0e2c4.size()-10 }; });
}

void QAccessibleActionInterface_DoAction(void* ptr, char* actionName)
{
	static_cast<QAccessibleActionInterface*>(ptr)->doAction(QString(actionName));
}

void QAccessibleActionInterface_DestroyQAccessibleActionInterface(void* ptr)
{
	static_cast<QAccessibleActionInterface*>(ptr)->~QAccessibleActionInterface();
}

void QAccessibleActionInterface_DestroyQAccessibleActionInterfaceDefault(void* ptr)
{

}

struct QtGui_PackedString QAccessibleActionInterface_LocalizedActionDescription(void* ptr, char* actionName)
{
	return ({ QByteArray t0e48f7 = static_cast<QAccessibleActionInterface*>(ptr)->localizedActionDescription(QString(actionName)).toUtf8(); QtGui_PackedString { const_cast<char*>(t0e48f7.prepend("WHITESPACE").constData()+10), t0e48f7.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_LocalizedActionDescriptionDefault(void* ptr, char* actionName)
{
		return ({ QByteArray taf9f9a = static_cast<QAccessibleActionInterface*>(ptr)->QAccessibleActionInterface::localizedActionDescription(QString(actionName)).toUtf8(); QtGui_PackedString { const_cast<char*>(taf9f9a.prepend("WHITESPACE").constData()+10), taf9f9a.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_LocalizedActionName(void* ptr, char* actionName)
{
	return ({ QByteArray t487891 = static_cast<QAccessibleActionInterface*>(ptr)->localizedActionName(QString(actionName)).toUtf8(); QtGui_PackedString { const_cast<char*>(t487891.prepend("WHITESPACE").constData()+10), t487891.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_LocalizedActionNameDefault(void* ptr, char* actionName)
{
		return ({ QByteArray t77f1fa = static_cast<QAccessibleActionInterface*>(ptr)->QAccessibleActionInterface::localizedActionName(QString(actionName)).toUtf8(); QtGui_PackedString { const_cast<char*>(t77f1fa.prepend("WHITESPACE").constData()+10), t77f1fa.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_ActionNames(void* ptr)
{
	return ({ QByteArray t71e118 = static_cast<QAccessibleActionInterface*>(ptr)->actionNames().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t71e118.prepend("WHITESPACE").constData()+10), t71e118.size()-10 }; });
}

struct QtGui_PackedString QAccessibleActionInterface_KeyBindingsForAction(void* ptr, char* actionName)
{
	return ({ QByteArray t2c6ae9 = static_cast<QAccessibleActionInterface*>(ptr)->keyBindingsForAction(QString(actionName)).join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t2c6ae9.prepend("WHITESPACE").constData()+10), t2c6ae9.size()-10 }; });
}

class MyQAccessibleEditableTextInterface: public QAccessibleEditableTextInterface
{
public:
	void deleteText(int startOffset, int endOffset) { callbackQAccessibleEditableTextInterface_DeleteText(this, startOffset, endOffset); };
	void insertText(int offset, const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtGui_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQAccessibleEditableTextInterface_InsertText(this, offset, textPacked); };
	void replaceText(int startOffset, int endOffset, const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtGui_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQAccessibleEditableTextInterface_ReplaceText(this, startOffset, endOffset, textPacked); };
	 ~MyQAccessibleEditableTextInterface() { callbackQAccessibleEditableTextInterface_DestroyQAccessibleEditableTextInterface(this); };
};

void QAccessibleEditableTextInterface_DeleteText(void* ptr, int startOffset, int endOffset)
{
	static_cast<QAccessibleEditableTextInterface*>(ptr)->deleteText(startOffset, endOffset);
}

void QAccessibleEditableTextInterface_InsertText(void* ptr, int offset, char* text)
{
	static_cast<QAccessibleEditableTextInterface*>(ptr)->insertText(offset, QString(text));
}

void QAccessibleEditableTextInterface_ReplaceText(void* ptr, int startOffset, int endOffset, char* text)
{
	static_cast<QAccessibleEditableTextInterface*>(ptr)->replaceText(startOffset, endOffset, QString(text));
}

void QAccessibleEditableTextInterface_DestroyQAccessibleEditableTextInterface(void* ptr)
{
	static_cast<QAccessibleEditableTextInterface*>(ptr)->~QAccessibleEditableTextInterface();
}

void QAccessibleEditableTextInterface_DestroyQAccessibleEditableTextInterfaceDefault(void* ptr)
{

}

class MyQAccessibleEvent: public QAccessibleEvent
{
public:
	MyQAccessibleEvent(QAccessibleInterface *interface, QAccessible::Event type) : QAccessibleEvent(interface, type) {};
	MyQAccessibleEvent(QObject *object, QAccessible::Event type) : QAccessibleEvent(object, type) {};
	 ~MyQAccessibleEvent() { callbackQAccessibleEvent_DestroyQAccessibleEvent(this); };
	QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAccessibleEvent_NewQAccessibleEvent2(void* interfa, long long ty)
{
	return new MyQAccessibleEvent(static_cast<QAccessibleInterface*>(interfa), static_cast<QAccessible::Event>(ty));
}

void* QAccessibleEvent_NewQAccessibleEvent(void* object, long long ty)
{
	return new MyQAccessibleEvent(static_cast<QObject*>(object), static_cast<QAccessible::Event>(ty));
}

void QAccessibleEvent_SetChild(void* ptr, int child)
{
	static_cast<QAccessibleEvent*>(ptr)->setChild(child);
}

void QAccessibleEvent_DestroyQAccessibleEvent(void* ptr)
{
	static_cast<QAccessibleEvent*>(ptr)->~QAccessibleEvent();
}

void QAccessibleEvent_DestroyQAccessibleEventDefault(void* ptr)
{

}

long long QAccessibleEvent_Type(void* ptr)
{
	return static_cast<QAccessibleEvent*>(ptr)->type();
}

void* QAccessibleEvent_AccessibleInterface(void* ptr)
{
	return static_cast<QAccessibleEvent*>(ptr)->accessibleInterface();
}

void* QAccessibleEvent_AccessibleInterfaceDefault(void* ptr)
{
	if (dynamic_cast<QAccessibleValueChangeEvent*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleValueChangeEvent*>(ptr)->QAccessibleValueChangeEvent::accessibleInterface();
	} else if (dynamic_cast<QAccessibleTextUpdateEvent*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleTextUpdateEvent*>(ptr)->QAccessibleTextUpdateEvent::accessibleInterface();
	} else if (dynamic_cast<QAccessibleTextSelectionEvent*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleTextSelectionEvent*>(ptr)->QAccessibleTextSelectionEvent::accessibleInterface();
	} else if (dynamic_cast<QAccessibleTextRemoveEvent*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleTextRemoveEvent*>(ptr)->QAccessibleTextRemoveEvent::accessibleInterface();
	} else if (dynamic_cast<QAccessibleTextInsertEvent*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleTextInsertEvent*>(ptr)->QAccessibleTextInsertEvent::accessibleInterface();
	} else if (dynamic_cast<QAccessibleTextCursorEvent*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleTextCursorEvent*>(ptr)->QAccessibleTextCursorEvent::accessibleInterface();
	} else if (dynamic_cast<QAccessibleTableModelChangeEvent*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->QAccessibleTableModelChangeEvent::accessibleInterface();
	} else if (dynamic_cast<QAccessibleStateChangeEvent*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleStateChangeEvent*>(ptr)->QAccessibleStateChangeEvent::accessibleInterface();
	} else {
		return static_cast<QAccessibleEvent*>(ptr)->QAccessibleEvent::accessibleInterface();
	}
}

void* QAccessibleEvent_Object(void* ptr)
{
	return static_cast<QAccessibleEvent*>(ptr)->object();
}

int QAccessibleEvent_Child(void* ptr)
{
	return static_cast<QAccessibleEvent*>(ptr)->child();
}

void* QAccessibleEvent_M_object(void* ptr)
{
	return static_cast<QAccessibleEvent*>(ptr)->m_object;
}

void QAccessibleEvent_SetM_object(void* ptr, void* vqo)
{
		static_cast<QAccessibleEvent*>(ptr)->m_object = static_cast<QObject*>(vqo);
}

long long QAccessibleEvent_M_type(void* ptr)
{
	return static_cast<QAccessibleEvent*>(ptr)->m_type;
}

void QAccessibleEvent_SetM_type(void* ptr, long long vqa)
{
	static_cast<QAccessibleEvent*>(ptr)->m_type = static_cast<QAccessible::Event>(vqa);
}

class MyQAccessibleInterface: public QAccessibleInterface
{
public:
	void * interface_cast(QAccessible::InterfaceType ty) { return callbackQAccessibleInterface_Interface_cast(this, ty); };
	void setText(QAccessible::Text t, const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtGui_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQAccessibleInterface_SetText(this, t, textPacked); };
	 ~MyQAccessibleInterface() { callbackQAccessibleInterface_DestroyQAccessibleInterface(this); };
	QAccessible::Role role() const { return static_cast<QAccessible::Role>(callbackQAccessibleInterface_Role(const_cast<void*>(static_cast<const void*>(this)))); };
	QAccessibleInterface * child(int index) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleInterface_Child(const_cast<void*>(static_cast<const void*>(this)), index)); };
	QAccessibleInterface * childAt(int x, int y) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleInterface_ChildAt(const_cast<void*>(static_cast<const void*>(this)), x, y)); };
	QAccessibleInterface * focusChild() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleInterface_FocusChild(const_cast<void*>(static_cast<const void*>(this)))); };
	QAccessibleInterface * parent() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleInterface_Parent(const_cast<void*>(static_cast<const void*>(this)))); };
	QColor backgroundColor() const { return *static_cast<QColor*>(callbackQAccessibleInterface_BackgroundColor(const_cast<void*>(static_cast<const void*>(this)))); };
	QColor foregroundColor() const { return *static_cast<QColor*>(callbackQAccessibleInterface_ForegroundColor(const_cast<void*>(static_cast<const void*>(this)))); };
	QObject * object() const { return static_cast<QObject*>(callbackQAccessibleInterface_Object(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect rect() const { return *static_cast<QRect*>(callbackQAccessibleInterface_Rect(const_cast<void*>(static_cast<const void*>(this)))); };
	QString text(QAccessible::Text t) const { return QString(callbackQAccessibleInterface_Text(const_cast<void*>(static_cast<const void*>(this)), t)); };
	
	QWindow * window() const { return static_cast<QWindow*>(callbackQAccessibleInterface_Window(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isValid() const { return callbackQAccessibleInterface_IsValid(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int childCount() const { return callbackQAccessibleInterface_ChildCount(const_cast<void*>(static_cast<const void*>(this))); };
	int indexOfChild(const QAccessibleInterface * child) const { return callbackQAccessibleInterface_IndexOfChild(const_cast<void*>(static_cast<const void*>(this)), const_cast<QAccessibleInterface*>(child)); };
};

void* QAccessibleInterface_ActionInterface(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->actionInterface();
}

void* QAccessibleInterface_TableCellInterface(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->tableCellInterface();
}

void* QAccessibleInterface_TableInterface(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->tableInterface();
}

void* QAccessibleInterface_TextInterface(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->textInterface();
}

void* QAccessibleInterface_ValueInterface(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->valueInterface();
}

void* QAccessibleInterface_Interface_cast(void* ptr, long long ty)
{
	return static_cast<QAccessibleInterface*>(ptr)->interface_cast(static_cast<QAccessible::InterfaceType>(ty));
}

void* QAccessibleInterface_Interface_castDefault(void* ptr, long long ty)
{
	if (dynamic_cast<QAccessibleObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::interface_cast(static_cast<QAccessible::InterfaceType>(ty));
	} else {
		return static_cast<QAccessibleInterface*>(ptr)->QAccessibleInterface::interface_cast(static_cast<QAccessible::InterfaceType>(ty));
	}
}

void QAccessibleInterface_SetText(void* ptr, long long t, char* text)
{
	static_cast<QAccessibleInterface*>(ptr)->setText(static_cast<QAccessible::Text>(t), QString(text));
}

void QAccessibleInterface_DestroyQAccessibleInterface(void* ptr)
{
	static_cast<QAccessibleInterface*>(ptr)->~QAccessibleInterface();
}

void QAccessibleInterface_DestroyQAccessibleInterfaceDefault(void* ptr)
{

}

long long QAccessibleInterface_Role(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->role();
}

void* QAccessibleInterface_Child(void* ptr, int index)
{
	return static_cast<QAccessibleInterface*>(ptr)->child(index);
}

void* QAccessibleInterface_ChildAt(void* ptr, int x, int y)
{
	return static_cast<QAccessibleInterface*>(ptr)->childAt(x, y);
}

void* QAccessibleInterface_FocusChild(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->focusChild();
}

void* QAccessibleInterface_FocusChildDefault(void* ptr)
{
	if (dynamic_cast<QAccessibleObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::focusChild();
	} else {
		return static_cast<QAccessibleInterface*>(ptr)->QAccessibleInterface::focusChild();
	}
}

void* QAccessibleInterface_Parent(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->parent();
}

void* QAccessibleInterface_BackgroundColor(void* ptr)
{
	return new QColor(static_cast<QAccessibleInterface*>(ptr)->backgroundColor());
}

void* QAccessibleInterface_BackgroundColorDefault(void* ptr)
{
	if (dynamic_cast<QAccessibleObject*>(static_cast<QObject*>(ptr))) {
		return new QColor(static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::backgroundColor());
	} else {
		return new QColor(static_cast<QAccessibleInterface*>(ptr)->QAccessibleInterface::backgroundColor());
	}
}

void* QAccessibleInterface_ForegroundColor(void* ptr)
{
	return new QColor(static_cast<QAccessibleInterface*>(ptr)->foregroundColor());
}

void* QAccessibleInterface_ForegroundColorDefault(void* ptr)
{
	if (dynamic_cast<QAccessibleObject*>(static_cast<QObject*>(ptr))) {
		return new QColor(static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::foregroundColor());
	} else {
		return new QColor(static_cast<QAccessibleInterface*>(ptr)->QAccessibleInterface::foregroundColor());
	}
}

void* QAccessibleInterface_Object(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->object();
}

void* QAccessibleInterface_Rect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QAccessibleInterface*>(ptr)->rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QAccessibleInterface_Text(void* ptr, long long t)
{
	return ({ QByteArray t0d7711 = static_cast<QAccessibleInterface*>(ptr)->text(static_cast<QAccessible::Text>(t)).toUtf8(); QtGui_PackedString { const_cast<char*>(t0d7711.prepend("WHITESPACE").constData()+10), t0d7711.size()-10 }; });
}

void* QAccessibleInterface_Window(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->window();
}

void* QAccessibleInterface_WindowDefault(void* ptr)
{
	if (dynamic_cast<QAccessibleObject*>(static_cast<QObject*>(ptr))) {
		return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::window();
	} else {
		return static_cast<QAccessibleInterface*>(ptr)->QAccessibleInterface::window();
	}
}

char QAccessibleInterface_IsValid(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->isValid();
}

int QAccessibleInterface_ChildCount(void* ptr)
{
	return static_cast<QAccessibleInterface*>(ptr)->childCount();
}

int QAccessibleInterface_IndexOfChild(void* ptr, void* child)
{
	return static_cast<QAccessibleInterface*>(ptr)->indexOfChild(static_cast<QAccessibleInterface*>(child));
}

class MyQAccessibleObject: public QAccessibleObject
{
public:
	void setText(QAccessible::Text t, const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtGui_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQAccessibleObject_SetText(this, t, textPacked); };
	 ~MyQAccessibleObject() { callbackQAccessibleObject_DestroyQAccessibleObject(this); };
	QAccessibleInterface * childAt(int x, int y) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleObject_ChildAt(const_cast<void*>(static_cast<const void*>(this)), x, y)); };
	QObject * object() const { return static_cast<QObject*>(callbackQAccessibleObject_Object(const_cast<void*>(static_cast<const void*>(this)))); };
	QRect rect() const { return *static_cast<QRect*>(callbackQAccessibleObject_Rect(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isValid() const { return callbackQAccessibleObject_IsValid(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	void * interface_cast(QAccessible::InterfaceType ty) { return callbackQAccessibleInterface_Interface_cast(this, ty); };
	QAccessible::Role role() const { return static_cast<QAccessible::Role>(callbackQAccessibleObject_Role(const_cast<void*>(static_cast<const void*>(this)))); };
	QAccessibleInterface * child(int index) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleObject_Child(const_cast<void*>(static_cast<const void*>(this)), index)); };
	QAccessibleInterface * focusChild() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleInterface_FocusChild(const_cast<void*>(static_cast<const void*>(this)))); };
	QAccessibleInterface * parent() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleObject_Parent(const_cast<void*>(static_cast<const void*>(this)))); };
	QColor backgroundColor() const { return *static_cast<QColor*>(callbackQAccessibleInterface_BackgroundColor(const_cast<void*>(static_cast<const void*>(this)))); };
	QColor foregroundColor() const { return *static_cast<QColor*>(callbackQAccessibleInterface_ForegroundColor(const_cast<void*>(static_cast<const void*>(this)))); };
	QString text(QAccessible::Text t) const { return QString(callbackQAccessibleObject_Text(const_cast<void*>(static_cast<const void*>(this)), t)); };
	QWindow * window() const { return static_cast<QWindow*>(callbackQAccessibleInterface_Window(const_cast<void*>(static_cast<const void*>(this)))); };
	int childCount() const { return callbackQAccessibleObject_ChildCount(const_cast<void*>(static_cast<const void*>(this))); };
	int indexOfChild(const QAccessibleInterface * child) const { return callbackQAccessibleObject_IndexOfChild(const_cast<void*>(static_cast<const void*>(this)), const_cast<QAccessibleInterface*>(child)); };
};

void QAccessibleObject_SetText(void* ptr, long long t, char* text)
{
	static_cast<QAccessibleObject*>(ptr)->setText(static_cast<QAccessible::Text>(t), QString(text));
}

void QAccessibleObject_SetTextDefault(void* ptr, long long t, char* text)
{
		static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::setText(static_cast<QAccessible::Text>(t), QString(text));
}

void QAccessibleObject_DestroyQAccessibleObject(void* ptr)
{
	static_cast<QAccessibleObject*>(ptr)->~QAccessibleObject();
}

void QAccessibleObject_DestroyQAccessibleObjectDefault(void* ptr)
{

}

void* QAccessibleObject_ChildAt(void* ptr, int x, int y)
{
	return static_cast<QAccessibleObject*>(ptr)->childAt(x, y);
}

void* QAccessibleObject_ChildAtDefault(void* ptr, int x, int y)
{
		return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::childAt(x, y);
}

void* QAccessibleObject_Object(void* ptr)
{
	return static_cast<QAccessibleObject*>(ptr)->object();
}

void* QAccessibleObject_ObjectDefault(void* ptr)
{
		return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::object();
}

void* QAccessibleObject_Rect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QAccessibleObject*>(ptr)->rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QAccessibleObject_RectDefault(void* ptr)
{
		return ({ QRect tmpValue = static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

char QAccessibleObject_IsValid(void* ptr)
{
	return static_cast<QAccessibleObject*>(ptr)->isValid();
}

char QAccessibleObject_IsValidDefault(void* ptr)
{
		return static_cast<QAccessibleObject*>(ptr)->QAccessibleObject::isValid();
}

long long QAccessibleObject_Role(void* ptr)
{
	return static_cast<QAccessibleObject*>(ptr)->role();
}

long long QAccessibleObject_RoleDefault(void* ptr)
{
	
}

void* QAccessibleObject_Child(void* ptr, int index)
{
	return static_cast<QAccessibleObject*>(ptr)->child(index);
}

void* QAccessibleObject_ChildDefault(void* ptr, int index)
{
	
}

void* QAccessibleObject_Parent(void* ptr)
{
	return static_cast<QAccessibleObject*>(ptr)->parent();
}

void* QAccessibleObject_ParentDefault(void* ptr)
{
	
}

struct QtGui_PackedString QAccessibleObject_Text(void* ptr, long long t)
{
	return ({ QByteArray td7ef98 = static_cast<QAccessibleObject*>(ptr)->text(static_cast<QAccessible::Text>(t)).toUtf8(); QtGui_PackedString { const_cast<char*>(td7ef98.prepend("WHITESPACE").constData()+10), td7ef98.size()-10 }; });
}

struct QtGui_PackedString QAccessibleObject_TextDefault(void* ptr, long long t)
{
	
}

int QAccessibleObject_ChildCount(void* ptr)
{
	return static_cast<QAccessibleObject*>(ptr)->childCount();
}

int QAccessibleObject_ChildCountDefault(void* ptr)
{
	
}

int QAccessibleObject_IndexOfChild(void* ptr, void* child)
{
	return static_cast<QAccessibleObject*>(ptr)->indexOfChild(static_cast<QAccessibleInterface*>(child));
}

int QAccessibleObject_IndexOfChildDefault(void* ptr, void* child)
{
	
}

class MyQAccessiblePlugin: public QAccessiblePlugin
{
public:
	MyQAccessiblePlugin(QObject *parent) : QAccessiblePlugin(parent) {};
	QAccessibleInterface * create(const QString & key, QObject * object) { QByteArray ta62f22 = key.toUtf8(); QtGui_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };return static_cast<QAccessibleInterface*>(callbackQAccessiblePlugin_Create(this, keyPacked, object)); };
	bool event(QEvent * e) { return callbackQAccessiblePlugin_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQAccessiblePlugin_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQAccessiblePlugin_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQAccessiblePlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQAccessiblePlugin_CustomEvent(this, event); };
	void deleteLater() { callbackQAccessiblePlugin_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQAccessiblePlugin_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQAccessiblePlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQAccessiblePlugin_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQAccessiblePlugin_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAccessiblePlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAccessiblePlugin_Create(void* ptr, char* key, void* object)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
		return static_cast<QAccessiblePlugin*>(ptr)->create(QString(key), static_cast<QOffscreenSurface*>(object));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
		return static_cast<QAccessiblePlugin*>(ptr)->create(QString(key), static_cast<QPaintDeviceWindow*>(object));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
		return static_cast<QAccessiblePlugin*>(ptr)->create(QString(key), static_cast<QPdfWriter*>(object));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
		return static_cast<QAccessiblePlugin*>(ptr)->create(QString(key), static_cast<QWindow*>(object));
	} else {
		return static_cast<QAccessiblePlugin*>(ptr)->create(QString(key), static_cast<QObject*>(object));
	}
}

void* QAccessiblePlugin_NewQAccessiblePlugin(void* parent)
{
	return new MyQAccessiblePlugin(static_cast<QObject*>(parent));
}

void QAccessiblePlugin_DestroyQAccessiblePlugin(void* ptr)
{
	static_cast<QAccessiblePlugin*>(ptr)->~QAccessiblePlugin();
}

void* QAccessiblePlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QAccessiblePlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QAccessiblePlugin___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QAccessiblePlugin___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAccessiblePlugin___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAccessiblePlugin___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QAccessiblePlugin___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAccessiblePlugin___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAccessiblePlugin___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QAccessiblePlugin___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QAccessiblePlugin___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAccessiblePlugin___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QAccessiblePlugin___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QAccessiblePlugin___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QAccessiblePlugin___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QAccessiblePlugin_EventDefault(void* ptr, void* e)
{
		return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::event(static_cast<QEvent*>(e));
}

char QAccessiblePlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QAccessiblePlugin_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::childEvent(static_cast<QChildEvent*>(event));
}

void QAccessiblePlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAccessiblePlugin_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::customEvent(static_cast<QEvent*>(event));
}

void QAccessiblePlugin_DeleteLaterDefault(void* ptr)
{
		static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::deleteLater();
}

void QAccessiblePlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QAccessiblePlugin_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QAccessiblePlugin_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QAccessiblePlugin*>(ptr)->QAccessiblePlugin::metaObject());
}

class MyQAccessibleStateChangeEvent: public QAccessibleStateChangeEvent
{
public:
	QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};

class MyQAccessibleTableCellInterface: public QAccessibleTableCellInterface
{
public:
	 ~MyQAccessibleTableCellInterface() { callbackQAccessibleTableCellInterface_DestroyQAccessibleTableCellInterface(this); };
	QAccessibleInterface * table() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleTableCellInterface_Table(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<QAccessibleInterface *> columnHeaderCells() const { return *static_cast<QList<QAccessibleInterface *>*>(callbackQAccessibleTableCellInterface_ColumnHeaderCells(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<QAccessibleInterface *> rowHeaderCells() const { return *static_cast<QList<QAccessibleInterface *>*>(callbackQAccessibleTableCellInterface_RowHeaderCells(const_cast<void*>(static_cast<const void*>(this)))); };
	bool isSelected() const { return callbackQAccessibleTableCellInterface_IsSelected(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	int columnExtent() const { return callbackQAccessibleTableCellInterface_ColumnExtent(const_cast<void*>(static_cast<const void*>(this))); };
	int columnIndex() const { return callbackQAccessibleTableCellInterface_ColumnIndex(const_cast<void*>(static_cast<const void*>(this))); };
	int rowExtent() const { return callbackQAccessibleTableCellInterface_RowExtent(const_cast<void*>(static_cast<const void*>(this))); };
	int rowIndex() const { return callbackQAccessibleTableCellInterface_RowIndex(const_cast<void*>(static_cast<const void*>(this))); };
};

void QAccessibleTableCellInterface_DestroyQAccessibleTableCellInterface(void* ptr)
{
	static_cast<QAccessibleTableCellInterface*>(ptr)->~QAccessibleTableCellInterface();
}

void QAccessibleTableCellInterface_DestroyQAccessibleTableCellInterfaceDefault(void* ptr)
{

}

void* QAccessibleTableCellInterface_Table(void* ptr)
{
	return static_cast<QAccessibleTableCellInterface*>(ptr)->table();
}

struct QtGui_PackedList QAccessibleTableCellInterface_ColumnHeaderCells(void* ptr)
{
	return ({ QList<QAccessibleInterface *>* tmpValue = new QList<QAccessibleInterface *>(static_cast<QAccessibleTableCellInterface*>(ptr)->columnHeaderCells()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QAccessibleTableCellInterface_RowHeaderCells(void* ptr)
{
	return ({ QList<QAccessibleInterface *>* tmpValue = new QList<QAccessibleInterface *>(static_cast<QAccessibleTableCellInterface*>(ptr)->rowHeaderCells()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

char QAccessibleTableCellInterface_IsSelected(void* ptr)
{
	return static_cast<QAccessibleTableCellInterface*>(ptr)->isSelected();
}

int QAccessibleTableCellInterface_ColumnExtent(void* ptr)
{
	return static_cast<QAccessibleTableCellInterface*>(ptr)->columnExtent();
}

int QAccessibleTableCellInterface_ColumnIndex(void* ptr)
{
	return static_cast<QAccessibleTableCellInterface*>(ptr)->columnIndex();
}

int QAccessibleTableCellInterface_RowExtent(void* ptr)
{
	return static_cast<QAccessibleTableCellInterface*>(ptr)->rowExtent();
}

int QAccessibleTableCellInterface_RowIndex(void* ptr)
{
	return static_cast<QAccessibleTableCellInterface*>(ptr)->rowIndex();
}

void* QAccessibleTableCellInterface___columnHeaderCells_atList(void* ptr, int i)
{
	return const_cast<QAccessibleInterface*>(static_cast<QList<QAccessibleInterface *>*>(ptr)->at(i));
}

void QAccessibleTableCellInterface___columnHeaderCells_setList(void* ptr, void* i)
{
	static_cast<QList<QAccessibleInterface *>*>(ptr)->append(static_cast<QAccessibleInterface*>(i));
}

void* QAccessibleTableCellInterface___columnHeaderCells_newList(void* ptr)
{
	return new QList<QAccessibleInterface *>;
}

void* QAccessibleTableCellInterface___rowHeaderCells_atList(void* ptr, int i)
{
	return const_cast<QAccessibleInterface*>(static_cast<QList<QAccessibleInterface *>*>(ptr)->at(i));
}

void QAccessibleTableCellInterface___rowHeaderCells_setList(void* ptr, void* i)
{
	static_cast<QList<QAccessibleInterface *>*>(ptr)->append(static_cast<QAccessibleInterface*>(i));
}

void* QAccessibleTableCellInterface___rowHeaderCells_newList(void* ptr)
{
	return new QList<QAccessibleInterface *>;
}

class MyQAccessibleTableInterface: public QAccessibleTableInterface
{
public:
	bool selectColumn(int column) { return callbackQAccessibleTableInterface_SelectColumn(this, column) != 0; };
	bool selectRow(int row) { return callbackQAccessibleTableInterface_SelectRow(this, row) != 0; };
	bool unselectColumn(int column) { return callbackQAccessibleTableInterface_UnselectColumn(this, column) != 0; };
	bool unselectRow(int row) { return callbackQAccessibleTableInterface_UnselectRow(this, row) != 0; };
	void modelChange(QAccessibleTableModelChangeEvent * event) { callbackQAccessibleTableInterface_ModelChange(this, event); };
	 ~MyQAccessibleTableInterface() { callbackQAccessibleTableInterface_DestroyQAccessibleTableInterface(this); };
	QAccessibleInterface * caption() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleTableInterface_Caption(const_cast<void*>(static_cast<const void*>(this)))); };
	QAccessibleInterface * cellAt(int row, int column) const { return static_cast<QAccessibleInterface*>(callbackQAccessibleTableInterface_CellAt(const_cast<void*>(static_cast<const void*>(this)), row, column)); };
	QAccessibleInterface * summary() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleTableInterface_Summary(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<QAccessibleInterface *> selectedCells() const { return *static_cast<QList<QAccessibleInterface *>*>(callbackQAccessibleTableInterface_SelectedCells(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<int> selectedColumns() const { return *static_cast<QList<int>*>(callbackQAccessibleTableInterface_SelectedColumns(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<int> selectedRows() const { return *static_cast<QList<int>*>(callbackQAccessibleTableInterface_SelectedRows(const_cast<void*>(static_cast<const void*>(this)))); };
	QString columnDescription(int column) const { return QString(callbackQAccessibleTableInterface_ColumnDescription(const_cast<void*>(static_cast<const void*>(this)), column)); };
	QString rowDescription(int row) const { return QString(callbackQAccessibleTableInterface_RowDescription(const_cast<void*>(static_cast<const void*>(this)), row)); };
	bool isColumnSelected(int column) const { return callbackQAccessibleTableInterface_IsColumnSelected(const_cast<void*>(static_cast<const void*>(this)), column) != 0; };
	bool isRowSelected(int row) const { return callbackQAccessibleTableInterface_IsRowSelected(const_cast<void*>(static_cast<const void*>(this)), row) != 0; };
	int columnCount() const { return callbackQAccessibleTableInterface_ColumnCount(const_cast<void*>(static_cast<const void*>(this))); };
	int rowCount() const { return callbackQAccessibleTableInterface_RowCount(const_cast<void*>(static_cast<const void*>(this))); };
	int selectedCellCount() const { return callbackQAccessibleTableInterface_SelectedCellCount(const_cast<void*>(static_cast<const void*>(this))); };
	int selectedColumnCount() const { return callbackQAccessibleTableInterface_SelectedColumnCount(const_cast<void*>(static_cast<const void*>(this))); };
	int selectedRowCount() const { return callbackQAccessibleTableInterface_SelectedRowCount(const_cast<void*>(static_cast<const void*>(this))); };
};

char QAccessibleTableInterface_SelectColumn(void* ptr, int column)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->selectColumn(column);
}

char QAccessibleTableInterface_SelectRow(void* ptr, int row)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->selectRow(row);
}

char QAccessibleTableInterface_UnselectColumn(void* ptr, int column)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->unselectColumn(column);
}

char QAccessibleTableInterface_UnselectRow(void* ptr, int row)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->unselectRow(row);
}

void QAccessibleTableInterface_ModelChange(void* ptr, void* event)
{
	static_cast<QAccessibleTableInterface*>(ptr)->modelChange(static_cast<QAccessibleTableModelChangeEvent*>(event));
}

void QAccessibleTableInterface_DestroyQAccessibleTableInterface(void* ptr)
{
	static_cast<QAccessibleTableInterface*>(ptr)->~QAccessibleTableInterface();
}

void QAccessibleTableInterface_DestroyQAccessibleTableInterfaceDefault(void* ptr)
{

}

void* QAccessibleTableInterface_Caption(void* ptr)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->caption();
}

void* QAccessibleTableInterface_CellAt(void* ptr, int row, int column)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->cellAt(row, column);
}

void* QAccessibleTableInterface_Summary(void* ptr)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->summary();
}

struct QtGui_PackedList QAccessibleTableInterface_SelectedCells(void* ptr)
{
	return ({ QList<QAccessibleInterface *>* tmpValue = new QList<QAccessibleInterface *>(static_cast<QAccessibleTableInterface*>(ptr)->selectedCells()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QAccessibleTableInterface_SelectedColumns(void* ptr)
{
	return ({ QList<int>* tmpValue = new QList<int>(static_cast<QAccessibleTableInterface*>(ptr)->selectedColumns()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QAccessibleTableInterface_SelectedRows(void* ptr)
{
	return ({ QList<int>* tmpValue = new QList<int>(static_cast<QAccessibleTableInterface*>(ptr)->selectedRows()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedString QAccessibleTableInterface_ColumnDescription(void* ptr, int column)
{
	return ({ QByteArray t31bac7 = static_cast<QAccessibleTableInterface*>(ptr)->columnDescription(column).toUtf8(); QtGui_PackedString { const_cast<char*>(t31bac7.prepend("WHITESPACE").constData()+10), t31bac7.size()-10 }; });
}

struct QtGui_PackedString QAccessibleTableInterface_RowDescription(void* ptr, int row)
{
	return ({ QByteArray t5db49c = static_cast<QAccessibleTableInterface*>(ptr)->rowDescription(row).toUtf8(); QtGui_PackedString { const_cast<char*>(t5db49c.prepend("WHITESPACE").constData()+10), t5db49c.size()-10 }; });
}

char QAccessibleTableInterface_IsColumnSelected(void* ptr, int column)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->isColumnSelected(column);
}

char QAccessibleTableInterface_IsRowSelected(void* ptr, int row)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->isRowSelected(row);
}

int QAccessibleTableInterface_ColumnCount(void* ptr)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->columnCount();
}

int QAccessibleTableInterface_RowCount(void* ptr)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->rowCount();
}

int QAccessibleTableInterface_SelectedCellCount(void* ptr)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->selectedCellCount();
}

int QAccessibleTableInterface_SelectedColumnCount(void* ptr)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->selectedColumnCount();
}

int QAccessibleTableInterface_SelectedRowCount(void* ptr)
{
	return static_cast<QAccessibleTableInterface*>(ptr)->selectedRowCount();
}

void* QAccessibleTableInterface___selectedCells_atList(void* ptr, int i)
{
	return const_cast<QAccessibleInterface*>(static_cast<QList<QAccessibleInterface *>*>(ptr)->at(i));
}

void QAccessibleTableInterface___selectedCells_setList(void* ptr, void* i)
{
	static_cast<QList<QAccessibleInterface *>*>(ptr)->append(static_cast<QAccessibleInterface*>(i));
}

void* QAccessibleTableInterface___selectedCells_newList(void* ptr)
{
	return new QList<QAccessibleInterface *>;
}

int QAccessibleTableInterface___selectedColumns_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QAccessibleTableInterface___selectedColumns_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QAccessibleTableInterface___selectedColumns_newList(void* ptr)
{
	return new QList<int>;
}

int QAccessibleTableInterface___selectedRows_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QAccessibleTableInterface___selectedRows_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QAccessibleTableInterface___selectedRows_newList(void* ptr)
{
	return new QList<int>;
}

class MyQAccessibleTableModelChangeEvent: public QAccessibleTableModelChangeEvent
{
public:
	MyQAccessibleTableModelChangeEvent(QAccessibleInterface *iface, ModelChangeType changeType) : QAccessibleTableModelChangeEvent(iface, changeType) {};
	MyQAccessibleTableModelChangeEvent(QObject *object, ModelChangeType changeType) : QAccessibleTableModelChangeEvent(object, changeType) {};
	QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAccessibleTableModelChangeEvent_NewQAccessibleTableModelChangeEvent2(void* iface, long long changeType)
{
	return new MyQAccessibleTableModelChangeEvent(static_cast<QAccessibleInterface*>(iface), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
}

void* QAccessibleTableModelChangeEvent_NewQAccessibleTableModelChangeEvent(void* object, long long changeType)
{
	return new MyQAccessibleTableModelChangeEvent(static_cast<QObject*>(object), static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
}

void QAccessibleTableModelChangeEvent_SetFirstColumn(void* ptr, int column)
{
	static_cast<QAccessibleTableModelChangeEvent*>(ptr)->setFirstColumn(column);
}

void QAccessibleTableModelChangeEvent_SetFirstRow(void* ptr, int row)
{
	static_cast<QAccessibleTableModelChangeEvent*>(ptr)->setFirstRow(row);
}

void QAccessibleTableModelChangeEvent_SetLastColumn(void* ptr, int column)
{
	static_cast<QAccessibleTableModelChangeEvent*>(ptr)->setLastColumn(column);
}

void QAccessibleTableModelChangeEvent_SetLastRow(void* ptr, int row)
{
	static_cast<QAccessibleTableModelChangeEvent*>(ptr)->setLastRow(row);
}

void QAccessibleTableModelChangeEvent_SetModelChangeType(void* ptr, long long changeType)
{
	static_cast<QAccessibleTableModelChangeEvent*>(ptr)->setModelChangeType(static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(changeType));
}

long long QAccessibleTableModelChangeEvent_ModelChangeType(void* ptr)
{
	return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->modelChangeType();
}

int QAccessibleTableModelChangeEvent_FirstColumn(void* ptr)
{
	return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->firstColumn();
}

int QAccessibleTableModelChangeEvent_FirstRow(void* ptr)
{
	return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->firstRow();
}

int QAccessibleTableModelChangeEvent_LastColumn(void* ptr)
{
	return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->lastColumn();
}

int QAccessibleTableModelChangeEvent_LastRow(void* ptr)
{
	return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->lastRow();
}

int QAccessibleTableModelChangeEvent_M_firstColumn(void* ptr)
{
	return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_firstColumn;
}

void QAccessibleTableModelChangeEvent_SetM_firstColumn(void* ptr, int vin)
{
	static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_firstColumn = vin;
}

int QAccessibleTableModelChangeEvent_M_firstRow(void* ptr)
{
	return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_firstRow;
}

void QAccessibleTableModelChangeEvent_SetM_firstRow(void* ptr, int vin)
{
	static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_firstRow = vin;
}

int QAccessibleTableModelChangeEvent_M_lastColumn(void* ptr)
{
	return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_lastColumn;
}

void QAccessibleTableModelChangeEvent_SetM_lastColumn(void* ptr, int vin)
{
	static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_lastColumn = vin;
}

int QAccessibleTableModelChangeEvent_M_lastRow(void* ptr)
{
	return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_lastRow;
}

void QAccessibleTableModelChangeEvent_SetM_lastRow(void* ptr, int vin)
{
	static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_lastRow = vin;
}

long long QAccessibleTableModelChangeEvent_M_modelChangeType(void* ptr)
{
	return static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_modelChangeType;
}

void QAccessibleTableModelChangeEvent_SetM_modelChangeType(void* ptr, long long vmo)
{
	static_cast<QAccessibleTableModelChangeEvent*>(ptr)->m_modelChangeType = static_cast<QAccessibleTableModelChangeEvent::ModelChangeType>(vmo);
}

class MyQAccessibleTextCursorEvent: public QAccessibleTextCursorEvent
{
public:
	MyQAccessibleTextCursorEvent(QAccessibleInterface *iface, int cursorPos) : QAccessibleTextCursorEvent(iface, cursorPos) {};
	MyQAccessibleTextCursorEvent(QObject *object, int cursorPos) : QAccessibleTextCursorEvent(object, cursorPos) {};
	QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAccessibleTextCursorEvent_NewQAccessibleTextCursorEvent2(void* iface, int cursorPos)
{
	return new MyQAccessibleTextCursorEvent(static_cast<QAccessibleInterface*>(iface), cursorPos);
}

void* QAccessibleTextCursorEvent_NewQAccessibleTextCursorEvent(void* object, int cursorPos)
{
	return new MyQAccessibleTextCursorEvent(static_cast<QObject*>(object), cursorPos);
}

void QAccessibleTextCursorEvent_SetCursorPosition(void* ptr, int position)
{
	static_cast<QAccessibleTextCursorEvent*>(ptr)->setCursorPosition(position);
}

int QAccessibleTextCursorEvent_CursorPosition(void* ptr)
{
	return static_cast<QAccessibleTextCursorEvent*>(ptr)->cursorPosition();
}

int QAccessibleTextCursorEvent_M_cursorPosition(void* ptr)
{
	return static_cast<QAccessibleTextCursorEvent*>(ptr)->m_cursorPosition;
}

void QAccessibleTextCursorEvent_SetM_cursorPosition(void* ptr, int vin)
{
	static_cast<QAccessibleTextCursorEvent*>(ptr)->m_cursorPosition = vin;
}

class MyQAccessibleTextInsertEvent: public QAccessibleTextInsertEvent
{
public:
	MyQAccessibleTextInsertEvent(QAccessibleInterface *iface, int position, const QString &text) : QAccessibleTextInsertEvent(iface, position, text) {};
	MyQAccessibleTextInsertEvent(QObject *object, int position, const QString &text) : QAccessibleTextInsertEvent(object, position, text) {};
	QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAccessibleTextInsertEvent_NewQAccessibleTextInsertEvent2(void* iface, int position, char* text)
{
	return new MyQAccessibleTextInsertEvent(static_cast<QAccessibleInterface*>(iface), position, QString(text));
}

void* QAccessibleTextInsertEvent_NewQAccessibleTextInsertEvent(void* object, int position, char* text)
{
	return new MyQAccessibleTextInsertEvent(static_cast<QObject*>(object), position, QString(text));
}

struct QtGui_PackedString QAccessibleTextInsertEvent_TextInserted(void* ptr)
{
	return ({ QByteArray te79f7b = static_cast<QAccessibleTextInsertEvent*>(ptr)->textInserted().toUtf8(); QtGui_PackedString { const_cast<char*>(te79f7b.prepend("WHITESPACE").constData()+10), te79f7b.size()-10 }; });
}

int QAccessibleTextInsertEvent_ChangePosition(void* ptr)
{
	return static_cast<QAccessibleTextInsertEvent*>(ptr)->changePosition();
}

int QAccessibleTextInsertEvent_M_position(void* ptr)
{
	return static_cast<QAccessibleTextInsertEvent*>(ptr)->m_position;
}

void QAccessibleTextInsertEvent_SetM_position(void* ptr, int vin)
{
	static_cast<QAccessibleTextInsertEvent*>(ptr)->m_position = vin;
}

struct QtGui_PackedString QAccessibleTextInsertEvent_M_text(void* ptr)
{
	return ({ QByteArray t1f901e = static_cast<QAccessibleTextInsertEvent*>(ptr)->m_text.toUtf8(); QtGui_PackedString { const_cast<char*>(t1f901e.prepend("WHITESPACE").constData()+10), t1f901e.size()-10 }; });
}

void QAccessibleTextInsertEvent_SetM_text(void* ptr, char* vqs)
{
	static_cast<QAccessibleTextInsertEvent*>(ptr)->m_text = QString(vqs);
}

class MyQAccessibleTextInterface: public QAccessibleTextInterface
{
public:
	void addSelection(int startOffset, int endOffset) { callbackQAccessibleTextInterface_AddSelection(this, startOffset, endOffset); };
	void removeSelection(int selectionIndex) { callbackQAccessibleTextInterface_RemoveSelection(this, selectionIndex); };
	void scrollToSubstring(int startIndex, int endIndex) { callbackQAccessibleTextInterface_ScrollToSubstring(this, startIndex, endIndex); };
	void setCursorPosition(int position) { callbackQAccessibleTextInterface_SetCursorPosition(this, position); };
	void setSelection(int selectionIndex, int startOffset, int endOffset) { callbackQAccessibleTextInterface_SetSelection(this, selectionIndex, startOffset, endOffset); };
	 ~MyQAccessibleTextInterface() { callbackQAccessibleTextInterface_DestroyQAccessibleTextInterface(this); };
	QRect characterRect(int offset) const { return *static_cast<QRect*>(callbackQAccessibleTextInterface_CharacterRect(const_cast<void*>(static_cast<const void*>(this)), offset)); };
	QString text(int startOffset, int endOffset) const { return QString(callbackQAccessibleTextInterface_Text(const_cast<void*>(static_cast<const void*>(this)), startOffset, endOffset)); };
	QString textAfterOffset(int offset, QAccessible::TextBoundaryType boundaryType, int * startOffset, int * endOffset) const { return QString(callbackQAccessibleTextInterface_TextAfterOffset(const_cast<void*>(static_cast<const void*>(this)), offset, boundaryType, *startOffset, *endOffset)); };
	QString textAtOffset(int offset, QAccessible::TextBoundaryType boundaryType, int * startOffset, int * endOffset) const { return QString(callbackQAccessibleTextInterface_TextAtOffset(const_cast<void*>(static_cast<const void*>(this)), offset, boundaryType, *startOffset, *endOffset)); };
	QString textBeforeOffset(int offset, QAccessible::TextBoundaryType boundaryType, int * startOffset, int * endOffset) const { return QString(callbackQAccessibleTextInterface_TextBeforeOffset(const_cast<void*>(static_cast<const void*>(this)), offset, boundaryType, *startOffset, *endOffset)); };
	int characterCount() const { return callbackQAccessibleTextInterface_CharacterCount(const_cast<void*>(static_cast<const void*>(this))); };
	int cursorPosition() const { return callbackQAccessibleTextInterface_CursorPosition(const_cast<void*>(static_cast<const void*>(this))); };
	int offsetAtPoint(const QPoint & point) const { return callbackQAccessibleTextInterface_OffsetAtPoint(const_cast<void*>(static_cast<const void*>(this)), const_cast<QPoint*>(&point)); };
	int selectionCount() const { return callbackQAccessibleTextInterface_SelectionCount(const_cast<void*>(static_cast<const void*>(this))); };
	void selection(int selectionIndex, int * startOffset, int * endOffset) const { callbackQAccessibleTextInterface_Selection(const_cast<void*>(static_cast<const void*>(this)), selectionIndex, *startOffset, *endOffset); };
};

void QAccessibleTextInterface_AddSelection(void* ptr, int startOffset, int endOffset)
{
	static_cast<QAccessibleTextInterface*>(ptr)->addSelection(startOffset, endOffset);
}

void QAccessibleTextInterface_RemoveSelection(void* ptr, int selectionIndex)
{
	static_cast<QAccessibleTextInterface*>(ptr)->removeSelection(selectionIndex);
}

void QAccessibleTextInterface_ScrollToSubstring(void* ptr, int startIndex, int endIndex)
{
	static_cast<QAccessibleTextInterface*>(ptr)->scrollToSubstring(startIndex, endIndex);
}

void QAccessibleTextInterface_SetCursorPosition(void* ptr, int position)
{
	static_cast<QAccessibleTextInterface*>(ptr)->setCursorPosition(position);
}

void QAccessibleTextInterface_SetSelection(void* ptr, int selectionIndex, int startOffset, int endOffset)
{
	static_cast<QAccessibleTextInterface*>(ptr)->setSelection(selectionIndex, startOffset, endOffset);
}

void QAccessibleTextInterface_DestroyQAccessibleTextInterface(void* ptr)
{
	static_cast<QAccessibleTextInterface*>(ptr)->~QAccessibleTextInterface();
}

void QAccessibleTextInterface_DestroyQAccessibleTextInterfaceDefault(void* ptr)
{

}

void* QAccessibleTextInterface_CharacterRect(void* ptr, int offset)
{
	return ({ QRect tmpValue = static_cast<QAccessibleTextInterface*>(ptr)->characterRect(offset); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QAccessibleTextInterface_Text(void* ptr, int startOffset, int endOffset)
{
	return ({ QByteArray td7097f = static_cast<QAccessibleTextInterface*>(ptr)->text(startOffset, endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(td7097f.prepend("WHITESPACE").constData()+10), td7097f.size()-10 }; });
}

struct QtGui_PackedString QAccessibleTextInterface_TextAfterOffset(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
	return ({ QByteArray t56e464 = static_cast<QAccessibleTextInterface*>(ptr)->textAfterOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(t56e464.prepend("WHITESPACE").constData()+10), t56e464.size()-10 }; });
}

struct QtGui_PackedString QAccessibleTextInterface_TextAfterOffsetDefault(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
		return ({ QByteArray t495d09 = static_cast<QAccessibleTextInterface*>(ptr)->QAccessibleTextInterface::textAfterOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(t495d09.prepend("WHITESPACE").constData()+10), t495d09.size()-10 }; });
}

struct QtGui_PackedString QAccessibleTextInterface_TextAtOffset(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
	return ({ QByteArray t01d82d = static_cast<QAccessibleTextInterface*>(ptr)->textAtOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(t01d82d.prepend("WHITESPACE").constData()+10), t01d82d.size()-10 }; });
}

struct QtGui_PackedString QAccessibleTextInterface_TextAtOffsetDefault(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
		return ({ QByteArray tb855b8 = static_cast<QAccessibleTextInterface*>(ptr)->QAccessibleTextInterface::textAtOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(tb855b8.prepend("WHITESPACE").constData()+10), tb855b8.size()-10 }; });
}

struct QtGui_PackedString QAccessibleTextInterface_TextBeforeOffset(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
	return ({ QByteArray tde81ca = static_cast<QAccessibleTextInterface*>(ptr)->textBeforeOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(tde81ca.prepend("WHITESPACE").constData()+10), tde81ca.size()-10 }; });
}

struct QtGui_PackedString QAccessibleTextInterface_TextBeforeOffsetDefault(void* ptr, int offset, long long boundaryType, int startOffset, int endOffset)
{
		return ({ QByteArray tb76866 = static_cast<QAccessibleTextInterface*>(ptr)->QAccessibleTextInterface::textBeforeOffset(offset, static_cast<QAccessible::TextBoundaryType>(boundaryType), &startOffset, &endOffset).toUtf8(); QtGui_PackedString { const_cast<char*>(tb76866.prepend("WHITESPACE").constData()+10), tb76866.size()-10 }; });
}

int QAccessibleTextInterface_CharacterCount(void* ptr)
{
	return static_cast<QAccessibleTextInterface*>(ptr)->characterCount();
}

int QAccessibleTextInterface_CursorPosition(void* ptr)
{
	return static_cast<QAccessibleTextInterface*>(ptr)->cursorPosition();
}

int QAccessibleTextInterface_OffsetAtPoint(void* ptr, void* point)
{
	return static_cast<QAccessibleTextInterface*>(ptr)->offsetAtPoint(*static_cast<QPoint*>(point));
}

int QAccessibleTextInterface_SelectionCount(void* ptr)
{
	return static_cast<QAccessibleTextInterface*>(ptr)->selectionCount();
}

void QAccessibleTextInterface_Selection(void* ptr, int selectionIndex, int startOffset, int endOffset)
{
	static_cast<QAccessibleTextInterface*>(ptr)->selection(selectionIndex, &startOffset, &endOffset);
}

class MyQAccessibleTextRemoveEvent: public QAccessibleTextRemoveEvent
{
public:
	MyQAccessibleTextRemoveEvent(QAccessibleInterface *iface, int position, const QString &text) : QAccessibleTextRemoveEvent(iface, position, text) {};
	MyQAccessibleTextRemoveEvent(QObject *object, int position, const QString &text) : QAccessibleTextRemoveEvent(object, position, text) {};
	QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAccessibleTextRemoveEvent_NewQAccessibleTextRemoveEvent2(void* iface, int position, char* text)
{
	return new MyQAccessibleTextRemoveEvent(static_cast<QAccessibleInterface*>(iface), position, QString(text));
}

void* QAccessibleTextRemoveEvent_NewQAccessibleTextRemoveEvent(void* object, int position, char* text)
{
	return new MyQAccessibleTextRemoveEvent(static_cast<QObject*>(object), position, QString(text));
}

struct QtGui_PackedString QAccessibleTextRemoveEvent_TextRemoved(void* ptr)
{
	return ({ QByteArray t7bb24c = static_cast<QAccessibleTextRemoveEvent*>(ptr)->textRemoved().toUtf8(); QtGui_PackedString { const_cast<char*>(t7bb24c.prepend("WHITESPACE").constData()+10), t7bb24c.size()-10 }; });
}

int QAccessibleTextRemoveEvent_ChangePosition(void* ptr)
{
	return static_cast<QAccessibleTextRemoveEvent*>(ptr)->changePosition();
}

int QAccessibleTextRemoveEvent_M_position(void* ptr)
{
	return static_cast<QAccessibleTextRemoveEvent*>(ptr)->m_position;
}

void QAccessibleTextRemoveEvent_SetM_position(void* ptr, int vin)
{
	static_cast<QAccessibleTextRemoveEvent*>(ptr)->m_position = vin;
}

struct QtGui_PackedString QAccessibleTextRemoveEvent_M_text(void* ptr)
{
	return ({ QByteArray tff23be = static_cast<QAccessibleTextRemoveEvent*>(ptr)->m_text.toUtf8(); QtGui_PackedString { const_cast<char*>(tff23be.prepend("WHITESPACE").constData()+10), tff23be.size()-10 }; });
}

void QAccessibleTextRemoveEvent_SetM_text(void* ptr, char* vqs)
{
	static_cast<QAccessibleTextRemoveEvent*>(ptr)->m_text = QString(vqs);
}

class MyQAccessibleTextSelectionEvent: public QAccessibleTextSelectionEvent
{
public:
	MyQAccessibleTextSelectionEvent(QAccessibleInterface *iface, int start, int end) : QAccessibleTextSelectionEvent(iface, start, end) {};
	MyQAccessibleTextSelectionEvent(QObject *object, int start, int end) : QAccessibleTextSelectionEvent(object, start, end) {};
	QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAccessibleTextSelectionEvent_NewQAccessibleTextSelectionEvent2(void* iface, int start, int end)
{
	return new MyQAccessibleTextSelectionEvent(static_cast<QAccessibleInterface*>(iface), start, end);
}

void* QAccessibleTextSelectionEvent_NewQAccessibleTextSelectionEvent(void* object, int start, int end)
{
	return new MyQAccessibleTextSelectionEvent(static_cast<QObject*>(object), start, end);
}

void QAccessibleTextSelectionEvent_SetSelection(void* ptr, int start, int end)
{
	static_cast<QAccessibleTextSelectionEvent*>(ptr)->setSelection(start, end);
}

int QAccessibleTextSelectionEvent_SelectionEnd(void* ptr)
{
	return static_cast<QAccessibleTextSelectionEvent*>(ptr)->selectionEnd();
}

int QAccessibleTextSelectionEvent_SelectionStart(void* ptr)
{
	return static_cast<QAccessibleTextSelectionEvent*>(ptr)->selectionStart();
}

int QAccessibleTextSelectionEvent_M_selectionEnd(void* ptr)
{
	return static_cast<QAccessibleTextSelectionEvent*>(ptr)->m_selectionEnd;
}

void QAccessibleTextSelectionEvent_SetM_selectionEnd(void* ptr, int vin)
{
	static_cast<QAccessibleTextSelectionEvent*>(ptr)->m_selectionEnd = vin;
}

int QAccessibleTextSelectionEvent_M_selectionStart(void* ptr)
{
	return static_cast<QAccessibleTextSelectionEvent*>(ptr)->m_selectionStart;
}

void QAccessibleTextSelectionEvent_SetM_selectionStart(void* ptr, int vin)
{
	static_cast<QAccessibleTextSelectionEvent*>(ptr)->m_selectionStart = vin;
}

class MyQAccessibleTextUpdateEvent: public QAccessibleTextUpdateEvent
{
public:
	MyQAccessibleTextUpdateEvent(QAccessibleInterface *iface, int position, const QString &oldText, const QString &text) : QAccessibleTextUpdateEvent(iface, position, oldText, text) {};
	MyQAccessibleTextUpdateEvent(QObject *object, int position, const QString &oldText, const QString &text) : QAccessibleTextUpdateEvent(object, position, oldText, text) {};
	QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAccessibleTextUpdateEvent_NewQAccessibleTextUpdateEvent2(void* iface, int position, char* oldText, char* text)
{
	return new MyQAccessibleTextUpdateEvent(static_cast<QAccessibleInterface*>(iface), position, QString(oldText), QString(text));
}

void* QAccessibleTextUpdateEvent_NewQAccessibleTextUpdateEvent(void* object, int position, char* oldText, char* text)
{
	return new MyQAccessibleTextUpdateEvent(static_cast<QObject*>(object), position, QString(oldText), QString(text));
}

struct QtGui_PackedString QAccessibleTextUpdateEvent_TextInserted(void* ptr)
{
	return ({ QByteArray t055e50 = static_cast<QAccessibleTextUpdateEvent*>(ptr)->textInserted().toUtf8(); QtGui_PackedString { const_cast<char*>(t055e50.prepend("WHITESPACE").constData()+10), t055e50.size()-10 }; });
}

struct QtGui_PackedString QAccessibleTextUpdateEvent_TextRemoved(void* ptr)
{
	return ({ QByteArray t313b9a = static_cast<QAccessibleTextUpdateEvent*>(ptr)->textRemoved().toUtf8(); QtGui_PackedString { const_cast<char*>(t313b9a.prepend("WHITESPACE").constData()+10), t313b9a.size()-10 }; });
}

int QAccessibleTextUpdateEvent_ChangePosition(void* ptr)
{
	return static_cast<QAccessibleTextUpdateEvent*>(ptr)->changePosition();
}

struct QtGui_PackedString QAccessibleTextUpdateEvent_M_oldText(void* ptr)
{
	return ({ QByteArray t602ea6 = static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_oldText.toUtf8(); QtGui_PackedString { const_cast<char*>(t602ea6.prepend("WHITESPACE").constData()+10), t602ea6.size()-10 }; });
}

void QAccessibleTextUpdateEvent_SetM_oldText(void* ptr, char* vqs)
{
	static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_oldText = QString(vqs);
}

int QAccessibleTextUpdateEvent_M_position(void* ptr)
{
	return static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_position;
}

void QAccessibleTextUpdateEvent_SetM_position(void* ptr, int vin)
{
	static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_position = vin;
}

struct QtGui_PackedString QAccessibleTextUpdateEvent_M_text(void* ptr)
{
	return ({ QByteArray tf01ee2 = static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_text.toUtf8(); QtGui_PackedString { const_cast<char*>(tf01ee2.prepend("WHITESPACE").constData()+10), tf01ee2.size()-10 }; });
}

void QAccessibleTextUpdateEvent_SetM_text(void* ptr, char* vqs)
{
	static_cast<QAccessibleTextUpdateEvent*>(ptr)->m_text = QString(vqs);
}

class MyQAccessibleValueChangeEvent: public QAccessibleValueChangeEvent
{
public:
	MyQAccessibleValueChangeEvent(QAccessibleInterface *iface, const QVariant &val) : QAccessibleValueChangeEvent(iface, val) {};
	MyQAccessibleValueChangeEvent(QObject *object, const QVariant &value) : QAccessibleValueChangeEvent(object, value) {};
	QAccessibleInterface * accessibleInterface() const { return static_cast<QAccessibleInterface*>(callbackQAccessibleEvent_AccessibleInterface(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QAccessibleValueChangeEvent_NewQAccessibleValueChangeEvent2(void* iface, void* val)
{
	return new MyQAccessibleValueChangeEvent(static_cast<QAccessibleInterface*>(iface), *static_cast<QVariant*>(val));
}

void* QAccessibleValueChangeEvent_NewQAccessibleValueChangeEvent(void* object, void* value)
{
	return new MyQAccessibleValueChangeEvent(static_cast<QObject*>(object), *static_cast<QVariant*>(value));
}

void QAccessibleValueChangeEvent_SetValue(void* ptr, void* value)
{
	static_cast<QAccessibleValueChangeEvent*>(ptr)->setValue(*static_cast<QVariant*>(value));
}

void* QAccessibleValueChangeEvent_Value(void* ptr)
{
	return new QVariant(static_cast<QAccessibleValueChangeEvent*>(ptr)->value());
}

void* QAccessibleValueChangeEvent_M_value(void* ptr)
{
	return new QVariant(static_cast<QAccessibleValueChangeEvent*>(ptr)->m_value);
}

void QAccessibleValueChangeEvent_SetM_value(void* ptr, void* vqv)
{
	static_cast<QAccessibleValueChangeEvent*>(ptr)->m_value = *static_cast<QVariant*>(vqv);
}

class MyQAccessibleValueInterface: public QAccessibleValueInterface
{
public:
	void setCurrentValue(const QVariant & value) { callbackQAccessibleValueInterface_SetCurrentValue(this, const_cast<QVariant*>(&value)); };
	 ~MyQAccessibleValueInterface() { callbackQAccessibleValueInterface_DestroyQAccessibleValueInterface(this); };
	QVariant currentValue() const { return *static_cast<QVariant*>(callbackQAccessibleValueInterface_CurrentValue(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant maximumValue() const { return *static_cast<QVariant*>(callbackQAccessibleValueInterface_MaximumValue(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant minimumStepSize() const { return *static_cast<QVariant*>(callbackQAccessibleValueInterface_MinimumStepSize(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant minimumValue() const { return *static_cast<QVariant*>(callbackQAccessibleValueInterface_MinimumValue(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QAccessibleValueInterface_SetCurrentValue(void* ptr, void* value)
{
	static_cast<QAccessibleValueInterface*>(ptr)->setCurrentValue(*static_cast<QVariant*>(value));
}

void QAccessibleValueInterface_DestroyQAccessibleValueInterface(void* ptr)
{
	static_cast<QAccessibleValueInterface*>(ptr)->~QAccessibleValueInterface();
}

void QAccessibleValueInterface_DestroyQAccessibleValueInterfaceDefault(void* ptr)
{

}

void* QAccessibleValueInterface_CurrentValue(void* ptr)
{
	return new QVariant(static_cast<QAccessibleValueInterface*>(ptr)->currentValue());
}

void* QAccessibleValueInterface_MaximumValue(void* ptr)
{
	return new QVariant(static_cast<QAccessibleValueInterface*>(ptr)->maximumValue());
}

void* QAccessibleValueInterface_MinimumStepSize(void* ptr)
{
	return new QVariant(static_cast<QAccessibleValueInterface*>(ptr)->minimumStepSize());
}

void* QAccessibleValueInterface_MinimumValue(void* ptr)
{
	return new QVariant(static_cast<QAccessibleValueInterface*>(ptr)->minimumValue());
}

class MyQActionEvent: public QActionEvent
{
public:
	MyQActionEvent(int type, QAction *action, QAction *before) : QActionEvent(type, action, before) {};
};

void* QActionEvent_NewQActionEvent(int ty, void* action, void* before)
{
	return new MyQActionEvent(ty, static_cast<QAction*>(action), static_cast<QAction*>(before));
}

void* QActionEvent_Action(void* ptr)
{
	return static_cast<QActionEvent*>(ptr)->action();
}

void* QActionEvent_Before(void* ptr)
{
	return static_cast<QActionEvent*>(ptr)->before();
}

void* QBackingStore_NewQBackingStore(void* window)
{
	return new QBackingStore(static_cast<QWindow*>(window));
}

void* QBackingStore_PaintDevice(void* ptr)
{
	return static_cast<QBackingStore*>(ptr)->paintDevice();
}

char QBackingStore_Scroll(void* ptr, void* area, int dx, int dy)
{
	return static_cast<QBackingStore*>(ptr)->scroll(*static_cast<QRegion*>(area), dx, dy);
}

void QBackingStore_BeginPaint(void* ptr, void* region)
{
	static_cast<QBackingStore*>(ptr)->beginPaint(*static_cast<QRegion*>(region));
}

void QBackingStore_EndPaint(void* ptr)
{
	static_cast<QBackingStore*>(ptr)->endPaint();
}

void QBackingStore_Flush(void* ptr, void* region, void* win, void* offset)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(win))) {
		static_cast<QBackingStore*>(ptr)->flush(*static_cast<QRegion*>(region), static_cast<QPaintDeviceWindow*>(win), *static_cast<QPoint*>(offset));
	} else {
		static_cast<QBackingStore*>(ptr)->flush(*static_cast<QRegion*>(region), static_cast<QWindow*>(win), *static_cast<QPoint*>(offset));
	}
}

void QBackingStore_Resize(void* ptr, void* size)
{
	static_cast<QBackingStore*>(ptr)->resize(*static_cast<QSize*>(size));
}

void QBackingStore_SetStaticContents(void* ptr, void* region)
{
	static_cast<QBackingStore*>(ptr)->setStaticContents(*static_cast<QRegion*>(region));
}

void QBackingStore_DestroyQBackingStore(void* ptr)
{
	static_cast<QBackingStore*>(ptr)->~QBackingStore();
}

void* QBackingStore_StaticContents(void* ptr)
{
	return new QRegion(static_cast<QBackingStore*>(ptr)->staticContents());
}

void* QBackingStore_Size(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QBackingStore*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QBackingStore_Window(void* ptr)
{
	return static_cast<QBackingStore*>(ptr)->window();
}

char QBackingStore_HasStaticContents(void* ptr)
{
	return static_cast<QBackingStore*>(ptr)->hasStaticContents();
}

class MyQBitmap: public QBitmap
{
public:
	MyQBitmap() : QBitmap() {};
	MyQBitmap(int width, int height) : QBitmap(width, height) {};
	MyQBitmap(const QBitmap &other) : QBitmap(other) {};
	MyQBitmap(const QPixmap &pixmap) : QBitmap(pixmap) {};
	MyQBitmap(const QSize &size) : QBitmap(size) {};
	MyQBitmap(const QString &fileName, const char *format) : QBitmap(fileName, format) {};
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPixmap_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};

void* QBitmap_QBitmap_FromData(void* size, char* bits, long long monoFormat)
{
	return new QBitmap(QBitmap::fromData(*static_cast<QSize*>(size), const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(bits))), static_cast<QImage::Format>(monoFormat)));
}

void* QBitmap_QBitmap_FromImage(void* image, long long flags)
{
	return new QBitmap(QBitmap::fromImage(*static_cast<QImage*>(image), static_cast<Qt::ImageConversionFlag>(flags)));
}

void* QBitmap_NewQBitmap()
{
	return new MyQBitmap();
}

void* QBitmap_NewQBitmap3(int width, int height)
{
	return new MyQBitmap(width, height);
}

void* QBitmap_NewQBitmap6(void* other)
{
	return new MyQBitmap(*static_cast<QBitmap*>(other));
}

void* QBitmap_NewQBitmap2(void* pixmap)
{
	return new MyQBitmap(*static_cast<QPixmap*>(pixmap));
}

void* QBitmap_NewQBitmap4(void* size)
{
	return new MyQBitmap(*static_cast<QSize*>(size));
}

void* QBitmap_NewQBitmap5(char* fileName, char* format)
{
	return new MyQBitmap(QString(fileName), const_cast<const char*>(format));
}

void QBitmap_Clear(void* ptr)
{
	static_cast<QBitmap*>(ptr)->clear();
}

void QBitmap_Swap(void* ptr, void* other)
{
	static_cast<QBitmap*>(ptr)->swap(*static_cast<QBitmap*>(other));
}

void QBitmap_DestroyQBitmap(void* ptr)
{
	static_cast<QBitmap*>(ptr)->~QBitmap();
}

void* QBitmap_Transformed(void* ptr, void* matrix)
{
	return new QBitmap(static_cast<QBitmap*>(ptr)->transformed(*static_cast<QTransform*>(matrix)));
}

void* QBrush_NewQBrush()
{
	return new QBrush();
}

void* QBrush_NewQBrush2(long long style)
{
	return new QBrush(static_cast<Qt::BrushStyle>(style));
}

void* QBrush_NewQBrush4(long long color, long long style)
{
	return new QBrush(static_cast<Qt::GlobalColor>(color), static_cast<Qt::BrushStyle>(style));
}

void* QBrush_NewQBrush6(long long color, void* pixmap)
{
	return new QBrush(static_cast<Qt::GlobalColor>(color), *static_cast<QPixmap*>(pixmap));
}

void* QBrush_NewQBrush9(void* other)
{
	return new QBrush(*static_cast<QBrush*>(other));
}

void* QBrush_NewQBrush3(void* color, long long style)
{
	return new QBrush(*static_cast<QColor*>(color), static_cast<Qt::BrushStyle>(style));
}

void* QBrush_NewQBrush5(void* color, void* pixmap)
{
	return new QBrush(*static_cast<QColor*>(color), *static_cast<QPixmap*>(pixmap));
}

void* QBrush_NewQBrush10(void* gradient)
{
	return new QBrush(*static_cast<QGradient*>(gradient));
}

void* QBrush_NewQBrush8(void* image)
{
	return new QBrush(*static_cast<QImage*>(image));
}

void* QBrush_NewQBrush7(void* pixmap)
{
	return new QBrush(*static_cast<QPixmap*>(pixmap));
}

void QBrush_SetColor2(void* ptr, long long color)
{
	static_cast<QBrush*>(ptr)->setColor(static_cast<Qt::GlobalColor>(color));
}

void QBrush_SetColor(void* ptr, void* color)
{
	static_cast<QBrush*>(ptr)->setColor(*static_cast<QColor*>(color));
}

void QBrush_SetStyle(void* ptr, long long style)
{
	static_cast<QBrush*>(ptr)->setStyle(static_cast<Qt::BrushStyle>(style));
}

void QBrush_SetTexture(void* ptr, void* pixmap)
{
	static_cast<QBrush*>(ptr)->setTexture(*static_cast<QPixmap*>(pixmap));
}

void QBrush_SetTextureImage(void* ptr, void* image)
{
	static_cast<QBrush*>(ptr)->setTextureImage(*static_cast<QImage*>(image));
}

void QBrush_SetTransform(void* ptr, void* matrix)
{
	static_cast<QBrush*>(ptr)->setTransform(*static_cast<QTransform*>(matrix));
}

void QBrush_Swap(void* ptr, void* other)
{
	static_cast<QBrush*>(ptr)->swap(*static_cast<QBrush*>(other));
}

void QBrush_DestroyQBrush(void* ptr)
{
	static_cast<QBrush*>(ptr)->~QBrush();
}

void* QBrush_TextureImage(void* ptr)
{
	return new QImage(static_cast<QBrush*>(ptr)->textureImage());
}

void* QBrush_Texture(void* ptr)
{
	return new QPixmap(static_cast<QBrush*>(ptr)->texture());
}

void* QBrush_Transform(void* ptr)
{
	return new QTransform(static_cast<QBrush*>(ptr)->transform());
}

long long QBrush_Style(void* ptr)
{
	return static_cast<QBrush*>(ptr)->style();
}

char QBrush_IsOpaque(void* ptr)
{
	return static_cast<QBrush*>(ptr)->isOpaque();
}

void* QBrush_Color(void* ptr)
{
	return const_cast<QColor*>(&static_cast<QBrush*>(ptr)->color());
}

void* QBrush_Gradient(void* ptr)
{
	return const_cast<QGradient*>(static_cast<QBrush*>(ptr)->gradient());
}

class MyQClipboard: public QClipboard
{
public:
	void Signal_Changed(QClipboard::Mode mode) { callbackQClipboard_Changed(this, mode); };
	void Signal_DataChanged() { callbackQClipboard_DataChanged(this); };
	void Signal_FindBufferChanged() { callbackQClipboard_FindBufferChanged(this); };
	void Signal_SelectionChanged() { callbackQClipboard_SelectionChanged(this); };
	bool event(QEvent * e) { return callbackQClipboard_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQClipboard_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQClipboard_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQClipboard_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQClipboard_CustomEvent(this, event); };
	void deleteLater() { callbackQClipboard_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQClipboard_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQClipboard_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQClipboard_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQClipboard_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQClipboard_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QClipboard_ConnectChanged(void* ptr)
{
	QObject::connect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)(QClipboard::Mode)>(&QClipboard::changed), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)(QClipboard::Mode)>(&MyQClipboard::Signal_Changed));
}

void QClipboard_DisconnectChanged(void* ptr)
{
	QObject::disconnect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)(QClipboard::Mode)>(&QClipboard::changed), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)(QClipboard::Mode)>(&MyQClipboard::Signal_Changed));
}

void QClipboard_Changed(void* ptr, long long mode)
{
	static_cast<QClipboard*>(ptr)->changed(static_cast<QClipboard::Mode>(mode));
}

void QClipboard_Clear(void* ptr, long long mode)
{
	static_cast<QClipboard*>(ptr)->clear(static_cast<QClipboard::Mode>(mode));
}

void QClipboard_ConnectDataChanged(void* ptr)
{
	QObject::connect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::dataChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_DataChanged));
}

void QClipboard_DisconnectDataChanged(void* ptr)
{
	QObject::disconnect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::dataChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_DataChanged));
}

void QClipboard_DataChanged(void* ptr)
{
	static_cast<QClipboard*>(ptr)->dataChanged();
}

void QClipboard_ConnectFindBufferChanged(void* ptr)
{
	QObject::connect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::findBufferChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_FindBufferChanged));
}

void QClipboard_DisconnectFindBufferChanged(void* ptr)
{
	QObject::disconnect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::findBufferChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_FindBufferChanged));
}

void QClipboard_FindBufferChanged(void* ptr)
{
	static_cast<QClipboard*>(ptr)->findBufferChanged();
}

void QClipboard_ConnectSelectionChanged(void* ptr)
{
	QObject::connect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::selectionChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_SelectionChanged));
}

void QClipboard_DisconnectSelectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QClipboard*>(ptr), static_cast<void (QClipboard::*)()>(&QClipboard::selectionChanged), static_cast<MyQClipboard*>(ptr), static_cast<void (MyQClipboard::*)()>(&MyQClipboard::Signal_SelectionChanged));
}

void QClipboard_SelectionChanged(void* ptr)
{
	static_cast<QClipboard*>(ptr)->selectionChanged();
}

void QClipboard_SetImage(void* ptr, void* image, long long mode)
{
	static_cast<QClipboard*>(ptr)->setImage(*static_cast<QImage*>(image), static_cast<QClipboard::Mode>(mode));
}

void QClipboard_SetMimeData(void* ptr, void* src, long long mode)
{
	static_cast<QClipboard*>(ptr)->setMimeData(static_cast<QMimeData*>(src), static_cast<QClipboard::Mode>(mode));
}

void QClipboard_SetPixmap(void* ptr, void* pixmap, long long mode)
{
	static_cast<QClipboard*>(ptr)->setPixmap(*static_cast<QPixmap*>(pixmap), static_cast<QClipboard::Mode>(mode));
}

void QClipboard_SetText(void* ptr, char* text, long long mode)
{
	static_cast<QClipboard*>(ptr)->setText(QString(text), static_cast<QClipboard::Mode>(mode));
}

void* QClipboard_Image(void* ptr, long long mode)
{
	return new QImage(static_cast<QClipboard*>(ptr)->image(static_cast<QClipboard::Mode>(mode)));
}

void* QClipboard_Pixmap(void* ptr, long long mode)
{
	return new QPixmap(static_cast<QClipboard*>(ptr)->pixmap(static_cast<QClipboard::Mode>(mode)));
}

struct QtGui_PackedString QClipboard_Text(void* ptr, long long mode)
{
	return ({ QByteArray tc36a83 = static_cast<QClipboard*>(ptr)->text(static_cast<QClipboard::Mode>(mode)).toUtf8(); QtGui_PackedString { const_cast<char*>(tc36a83.prepend("WHITESPACE").constData()+10), tc36a83.size()-10 }; });
}

struct QtGui_PackedString QClipboard_Text2(void* ptr, char* subtype, long long mode)
{
	return ({ QByteArray te48192 = static_cast<QClipboard*>(ptr)->text(*(new QString(subtype)), static_cast<QClipboard::Mode>(mode)).toUtf8(); QtGui_PackedString { const_cast<char*>(te48192.prepend("WHITESPACE").constData()+10), te48192.size()-10 }; });
}

char QClipboard_OwnsClipboard(void* ptr)
{
	return static_cast<QClipboard*>(ptr)->ownsClipboard();
}

char QClipboard_OwnsFindBuffer(void* ptr)
{
	return static_cast<QClipboard*>(ptr)->ownsFindBuffer();
}

char QClipboard_OwnsSelection(void* ptr)
{
	return static_cast<QClipboard*>(ptr)->ownsSelection();
}

char QClipboard_SupportsFindBuffer(void* ptr)
{
	return static_cast<QClipboard*>(ptr)->supportsFindBuffer();
}

char QClipboard_SupportsSelection(void* ptr)
{
	return static_cast<QClipboard*>(ptr)->supportsSelection();
}

void* QClipboard_MimeData(void* ptr, long long mode)
{
	return const_cast<QMimeData*>(static_cast<QClipboard*>(ptr)->mimeData(static_cast<QClipboard::Mode>(mode)));
}

void* QClipboard___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QClipboard___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QClipboard___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QClipboard___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QClipboard___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QClipboard___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QClipboard___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QClipboard___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QClipboard___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QClipboard___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QClipboard___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QClipboard___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QClipboard___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QClipboard___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QClipboard___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QClipboard_EventDefault(void* ptr, void* e)
{
		return static_cast<QClipboard*>(ptr)->QClipboard::event(static_cast<QEvent*>(e));
}

char QClipboard_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QClipboard*>(ptr)->QClipboard::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QClipboard*>(ptr)->QClipboard::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QClipboard*>(ptr)->QClipboard::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QClipboard*>(ptr)->QClipboard::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QClipboard*>(ptr)->QClipboard::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QClipboard_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QClipboard*>(ptr)->QClipboard::childEvent(static_cast<QChildEvent*>(event));
}

void QClipboard_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QClipboard*>(ptr)->QClipboard::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QClipboard_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QClipboard*>(ptr)->QClipboard::customEvent(static_cast<QEvent*>(event));
}

void QClipboard_DeleteLaterDefault(void* ptr)
{
		static_cast<QClipboard*>(ptr)->QClipboard::deleteLater();
}

void QClipboard_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QClipboard*>(ptr)->QClipboard::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QClipboard_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QClipboard*>(ptr)->QClipboard::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QClipboard_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QClipboard*>(ptr)->QClipboard::metaObject());
}

class MyQCloseEvent: public QCloseEvent
{
public:
	MyQCloseEvent() : QCloseEvent() {};
};

void* QCloseEvent_NewQCloseEvent()
{
	return new MyQCloseEvent();
}

void* QColor_QColor_FromHsv(int h, int s, int v, int a)
{
	return new QColor(QColor::fromHsv(h, s, v, a));
}

void* QColor_QColor_FromRgb2(int r, int g, int b, int a)
{
	return new QColor(QColor::fromRgb(r, g, b, a));
}

void QColor_SetRgbF(void* ptr, double r, double g, double b, double a)
{
	static_cast<QColor*>(ptr)->setRgbF(r, g, b, a);
}

void* QColor_ConvertTo(void* ptr, long long colorSpec)
{
	return new QColor(static_cast<QColor*>(ptr)->convertTo(static_cast<QColor::Spec>(colorSpec)));
}

void* QColor_QColor_FromCmyk(int c, int m, int y, int k, int a)
{
	return new QColor(QColor::fromCmyk(c, m, y, k, a));
}

void* QColor_QColor_FromCmykF(double c, double m, double y, double k, double a)
{
	return new QColor(QColor::fromCmykF(c, m, y, k, a));
}

void* QColor_QColor_FromHsl(int h, int s, int l, int a)
{
	return new QColor(QColor::fromHsl(h, s, l, a));
}

void* QColor_QColor_FromHslF(double h, double s, double l, double a)
{
	return new QColor(QColor::fromHslF(h, s, l, a));
}

void* QColor_QColor_FromHsvF(double h, double s, double v, double a)
{
	return new QColor(QColor::fromHsvF(h, s, v, a));
}

void* QColor_QColor_FromRgbF(double r, double g, double b, double a)
{
	return new QColor(QColor::fromRgbF(r, g, b, a));
}

void* QColor_QColor_FromRgba642(void* rgba64)
{
	return new QColor(QColor::fromRgba64(*static_cast<QRgba64*>(rgba64)));
}

void* QColor_QColor_FromRgba64(unsigned short r, unsigned short g, unsigned short b, unsigned short a)
{
	return new QColor(QColor::fromRgba64(r, g, b, a));
}

void* QColor_NewQColor()
{
	return new QColor();
}

void* QColor_NewQColor11(void* other)
{
	return new QColor(*static_cast<QColor*>(other));
}

void* QColor_NewQColor8(void* name)
{
	return new QColor(*static_cast<QLatin1String*>(name));
}

void* QColor_NewQColor5(void* rgba64)
{
	return new QColor(*static_cast<QRgba64*>(rgba64));
}

void* QColor_NewQColor2(long long color)
{
	return new QColor(static_cast<Qt::GlobalColor>(color));
}

void* QColor_NewQColor10(void* color)
{
	return new QColor(*static_cast<QColor*>(color));
}

void* QColor_NewQColor6(char* name)
{
	return new QColor(QString(name));
}

void* QColor_NewQColor7(char* name)
{
	return new QColor(const_cast<const char*>(name));
}

void* QColor_NewQColor3(int r, int g, int b, int a)
{
	return new QColor(r, g, b, a);
}

struct QtGui_PackedString QColor_QColor_ColorNames()
{
	return ({ QByteArray t1b28c6 = QColor::colorNames().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t1b28c6.prepend("WHITESPACE").constData()+10), t1b28c6.size()-10 }; });
}

char QColor_QColor_IsValidColor2(void* name)
{
	return QColor::isValidColor(*static_cast<QLatin1String*>(name));
}

char QColor_QColor_IsValidColor(char* name)
{
	return QColor::isValidColor(QString(name));
}

void QColor_GetCmyk(void* ptr, int c, int m, int y, int k, int a)
{
	static_cast<QColor*>(ptr)->getCmyk(&c, &m, &y, &k, &a);
}

void QColor_GetCmykF(void* ptr, double c, double m, double y, double k, double a)
{
	static_cast<QColor*>(ptr)->getCmykF(&c, &m, &y, &k, &a);
}

void QColor_SetAlpha(void* ptr, int alpha)
{
	static_cast<QColor*>(ptr)->setAlpha(alpha);
}

void QColor_SetAlphaF(void* ptr, double alpha)
{
	static_cast<QColor*>(ptr)->setAlphaF(alpha);
}

void QColor_SetBlue(void* ptr, int blue)
{
	static_cast<QColor*>(ptr)->setBlue(blue);
}

void QColor_SetBlueF(void* ptr, double blue)
{
	static_cast<QColor*>(ptr)->setBlueF(blue);
}

void QColor_SetCmyk(void* ptr, int c, int m, int y, int k, int a)
{
	static_cast<QColor*>(ptr)->setCmyk(c, m, y, k, a);
}

void QColor_SetCmykF(void* ptr, double c, double m, double y, double k, double a)
{
	static_cast<QColor*>(ptr)->setCmykF(c, m, y, k, a);
}

void QColor_SetGreen(void* ptr, int green)
{
	static_cast<QColor*>(ptr)->setGreen(green);
}

void QColor_SetGreenF(void* ptr, double green)
{
	static_cast<QColor*>(ptr)->setGreenF(green);
}

void QColor_SetHsl(void* ptr, int h, int s, int l, int a)
{
	static_cast<QColor*>(ptr)->setHsl(h, s, l, a);
}

void QColor_SetHslF(void* ptr, double h, double s, double l, double a)
{
	static_cast<QColor*>(ptr)->setHslF(h, s, l, a);
}

void QColor_SetHsv(void* ptr, int h, int s, int v, int a)
{
	static_cast<QColor*>(ptr)->setHsv(h, s, v, a);
}

void QColor_SetHsvF(void* ptr, double h, double s, double v, double a)
{
	static_cast<QColor*>(ptr)->setHsvF(h, s, v, a);
}

void QColor_SetNamedColor2(void* ptr, void* name)
{
	static_cast<QColor*>(ptr)->setNamedColor(*static_cast<QLatin1String*>(name));
}

void QColor_SetNamedColor(void* ptr, char* name)
{
	static_cast<QColor*>(ptr)->setNamedColor(QString(name));
}

void QColor_SetRed(void* ptr, int red)
{
	static_cast<QColor*>(ptr)->setRed(red);
}

void QColor_SetRedF(void* ptr, double red)
{
	static_cast<QColor*>(ptr)->setRedF(red);
}

void QColor_SetRgb(void* ptr, int r, int g, int b, int a)
{
	static_cast<QColor*>(ptr)->setRgb(r, g, b, a);
}

void QColor_SetRgba64(void* ptr, void* rgba)
{
	static_cast<QColor*>(ptr)->setRgba64(*static_cast<QRgba64*>(rgba));
}

void* QColor_Darker(void* ptr, int factor)
{
	return new QColor(static_cast<QColor*>(ptr)->darker(factor));
}

void* QColor_Lighter(void* ptr, int factor)
{
	return new QColor(static_cast<QColor*>(ptr)->lighter(factor));
}

void* QColor_ToCmyk(void* ptr)
{
	return new QColor(static_cast<QColor*>(ptr)->toCmyk());
}

void* QColor_ToHsl(void* ptr)
{
	return new QColor(static_cast<QColor*>(ptr)->toHsl());
}

void* QColor_ToHsv(void* ptr)
{
	return new QColor(static_cast<QColor*>(ptr)->toHsv());
}

void* QColor_ToRgb(void* ptr)
{
	return new QColor(static_cast<QColor*>(ptr)->toRgb());
}

struct QtGui_PackedString QColor_Name(void* ptr)
{
	return ({ QByteArray t9b3be4 = static_cast<QColor*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(t9b3be4.prepend("WHITESPACE").constData()+10), t9b3be4.size()-10 }; });
}

struct QtGui_PackedString QColor_Name2(void* ptr, long long format)
{
	return ({ QByteArray t4331f3 = static_cast<QColor*>(ptr)->name(static_cast<QColor::NameFormat>(format)).toUtf8(); QtGui_PackedString { const_cast<char*>(t4331f3.prepend("WHITESPACE").constData()+10), t4331f3.size()-10 }; });
}

long long QColor_Spec(void* ptr)
{
	return static_cast<QColor*>(ptr)->spec();
}

char QColor_IsValid(void* ptr)
{
	return static_cast<QColor*>(ptr)->isValid();
}

int QColor_Alpha(void* ptr)
{
	return static_cast<QColor*>(ptr)->alpha();
}

int QColor_Black(void* ptr)
{
	return static_cast<QColor*>(ptr)->black();
}

int QColor_Blue(void* ptr)
{
	return static_cast<QColor*>(ptr)->blue();
}

int QColor_Cyan(void* ptr)
{
	return static_cast<QColor*>(ptr)->cyan();
}

int QColor_Green(void* ptr)
{
	return static_cast<QColor*>(ptr)->green();
}

int QColor_HslHue(void* ptr)
{
	return static_cast<QColor*>(ptr)->hslHue();
}

int QColor_HslSaturation(void* ptr)
{
	return static_cast<QColor*>(ptr)->hslSaturation();
}

int QColor_HsvHue(void* ptr)
{
	return static_cast<QColor*>(ptr)->hsvHue();
}

int QColor_HsvSaturation(void* ptr)
{
	return static_cast<QColor*>(ptr)->hsvSaturation();
}

int QColor_Hue(void* ptr)
{
	return static_cast<QColor*>(ptr)->hue();
}

int QColor_Lightness(void* ptr)
{
	return static_cast<QColor*>(ptr)->lightness();
}

int QColor_Magenta(void* ptr)
{
	return static_cast<QColor*>(ptr)->magenta();
}

int QColor_Red(void* ptr)
{
	return static_cast<QColor*>(ptr)->red();
}

int QColor_Saturation(void* ptr)
{
	return static_cast<QColor*>(ptr)->saturation();
}

int QColor_Value(void* ptr)
{
	return static_cast<QColor*>(ptr)->value();
}

int QColor_Yellow(void* ptr)
{
	return static_cast<QColor*>(ptr)->yellow();
}

double QColor_AlphaF(void* ptr)
{
	return static_cast<QColor*>(ptr)->alphaF();
}

double QColor_BlackF(void* ptr)
{
	return static_cast<QColor*>(ptr)->blackF();
}

double QColor_BlueF(void* ptr)
{
	return static_cast<QColor*>(ptr)->blueF();
}

double QColor_CyanF(void* ptr)
{
	return static_cast<QColor*>(ptr)->cyanF();
}

double QColor_GreenF(void* ptr)
{
	return static_cast<QColor*>(ptr)->greenF();
}

double QColor_HslHueF(void* ptr)
{
	return static_cast<QColor*>(ptr)->hslHueF();
}

double QColor_HslSaturationF(void* ptr)
{
	return static_cast<QColor*>(ptr)->hslSaturationF();
}

double QColor_HsvHueF(void* ptr)
{
	return static_cast<QColor*>(ptr)->hsvHueF();
}

double QColor_HsvSaturationF(void* ptr)
{
	return static_cast<QColor*>(ptr)->hsvSaturationF();
}

double QColor_HueF(void* ptr)
{
	return static_cast<QColor*>(ptr)->hueF();
}

double QColor_LightnessF(void* ptr)
{
	return static_cast<QColor*>(ptr)->lightnessF();
}

double QColor_MagentaF(void* ptr)
{
	return static_cast<QColor*>(ptr)->magentaF();
}

double QColor_RedF(void* ptr)
{
	return static_cast<QColor*>(ptr)->redF();
}

double QColor_SaturationF(void* ptr)
{
	return static_cast<QColor*>(ptr)->saturationF();
}

double QColor_ValueF(void* ptr)
{
	return static_cast<QColor*>(ptr)->valueF();
}

double QColor_YellowF(void* ptr)
{
	return static_cast<QColor*>(ptr)->yellowF();
}

void QColor_GetHsl(void* ptr, int h, int s, int l, int a)
{
	static_cast<QColor*>(ptr)->getHsl(&h, &s, &l, &a);
}

void QColor_GetHslF(void* ptr, double h, double s, double l, double a)
{
	static_cast<QColor*>(ptr)->getHslF(&h, &s, &l, &a);
}

void QColor_GetHsv(void* ptr, int h, int s, int v, int a)
{
	static_cast<QColor*>(ptr)->getHsv(&h, &s, &v, &a);
}

void QColor_GetHsvF(void* ptr, double h, double s, double v, double a)
{
	static_cast<QColor*>(ptr)->getHsvF(&h, &s, &v, &a);
}

void QColor_GetRgb(void* ptr, int r, int g, int b, int a)
{
	static_cast<QColor*>(ptr)->getRgb(&r, &g, &b, &a);
}

void QColor_GetRgbF(void* ptr, double r, double g, double b, double a)
{
	static_cast<QColor*>(ptr)->getRgbF(&r, &g, &b, &a);
}

void* QColor_ToVariant(void* ptr)
{
	return new QVariant(*static_cast<QColor*>(ptr));
}

void* QConicalGradient_NewQConicalGradient()
{
	return new QConicalGradient();
}

void* QConicalGradient_NewQConicalGradient2(void* center, double angle)
{
	return new QConicalGradient(*static_cast<QPointF*>(center), angle);
}

void* QConicalGradient_NewQConicalGradient3(double cx, double cy, double angle)
{
	return new QConicalGradient(cx, cy, angle);
}

void QConicalGradient_SetAngle(void* ptr, double angle)
{
	static_cast<QConicalGradient*>(ptr)->setAngle(angle);
}

void QConicalGradient_SetCenter(void* ptr, void* center)
{
	static_cast<QConicalGradient*>(ptr)->setCenter(*static_cast<QPointF*>(center));
}

void QConicalGradient_SetCenter2(void* ptr, double x, double y)
{
	static_cast<QConicalGradient*>(ptr)->setCenter(x, y);
}

void* QConicalGradient_Center(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QConicalGradient*>(ptr)->center(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

double QConicalGradient_Angle(void* ptr)
{
	return static_cast<QConicalGradient*>(ptr)->angle();
}

class MyQContextMenuEvent: public QContextMenuEvent
{
public:
	MyQContextMenuEvent(Reason reason, const QPoint &pos) : QContextMenuEvent(reason, pos) {};
	MyQContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos) : QContextMenuEvent(reason, pos, globalPos) {};
	MyQContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos, Qt::KeyboardModifiers modifiers) : QContextMenuEvent(reason, pos, globalPos, modifiers) {};
};

void* QContextMenuEvent_NewQContextMenuEvent3(long long reason, void* pos)
{
	return new MyQContextMenuEvent(static_cast<QContextMenuEvent::Reason>(reason), *static_cast<QPoint*>(pos));
}

void* QContextMenuEvent_NewQContextMenuEvent2(long long reason, void* pos, void* globalPos)
{
	return new MyQContextMenuEvent(static_cast<QContextMenuEvent::Reason>(reason), *static_cast<QPoint*>(pos), *static_cast<QPoint*>(globalPos));
}

void* QContextMenuEvent_NewQContextMenuEvent(long long reason, void* pos, void* globalPos, long long modifiers)
{
	return new MyQContextMenuEvent(static_cast<QContextMenuEvent::Reason>(reason), *static_cast<QPoint*>(pos), *static_cast<QPoint*>(globalPos), static_cast<Qt::KeyboardModifier>(modifiers));
}

long long QContextMenuEvent_Reason(void* ptr)
{
	return static_cast<QContextMenuEvent*>(ptr)->reason();
}

void* QContextMenuEvent_GlobalPos(void* ptr)
{
	return const_cast<QPoint*>(&static_cast<QContextMenuEvent*>(ptr)->globalPos());
}

void* QContextMenuEvent_Pos(void* ptr)
{
	return const_cast<QPoint*>(&static_cast<QContextMenuEvent*>(ptr)->pos());
}

int QContextMenuEvent_GlobalX(void* ptr)
{
	return static_cast<QContextMenuEvent*>(ptr)->globalX();
}

int QContextMenuEvent_GlobalY(void* ptr)
{
	return static_cast<QContextMenuEvent*>(ptr)->globalY();
}

int QContextMenuEvent_X(void* ptr)
{
	return static_cast<QContextMenuEvent*>(ptr)->x();
}

int QContextMenuEvent_Y(void* ptr)
{
	return static_cast<QContextMenuEvent*>(ptr)->y();
}

void* QContextMenuEvent_Gp(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QContextMenuEvent*>(ptr)->gp; new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QContextMenuEvent_SetGp(void* ptr, void* vqp)
{
	static_cast<QContextMenuEvent*>(ptr)->gp = *static_cast<QPoint*>(vqp);
}

void* QContextMenuEvent_P(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QContextMenuEvent*>(ptr)->p; new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QContextMenuEvent_SetP(void* ptr, void* vqp)
{
	static_cast<QContextMenuEvent*>(ptr)->p = *static_cast<QPoint*>(vqp);
}

void* QCursor_NewQCursor()
{
	return new QCursor();
}

void* QCursor_NewQCursor6(void* other)
{
	return new QCursor(*static_cast<QCursor*>(other));
}

void* QCursor_NewQCursor2(long long shape)
{
	return new QCursor(static_cast<Qt::CursorShape>(shape));
}

void* QCursor_NewQCursor3(void* bitmap, void* mask, int hotX, int hotY)
{
	return new QCursor(*static_cast<QBitmap*>(bitmap), *static_cast<QBitmap*>(mask), hotX, hotY);
}

void* QCursor_NewQCursor5(void* c)
{
	return new QCursor(*static_cast<QCursor*>(c));
}

void* QCursor_NewQCursor4(void* pixmap, int hotX, int hotY)
{
	return new QCursor(*static_cast<QPixmap*>(pixmap), hotX, hotY);
}

void* QCursor_QCursor_Pos()
{
	return ({ QPoint tmpValue = QCursor::pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QCursor_QCursor_Pos2(void* screen)
{
	return ({ QPoint tmpValue = QCursor::pos(static_cast<QScreen*>(screen)); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QCursor_QCursor_SetPos4(void* screen, void* p)
{
	QCursor::setPos(static_cast<QScreen*>(screen), *static_cast<QPoint*>(p));
}

void QCursor_QCursor_SetPos2(void* screen, int x, int y)
{
	QCursor::setPos(static_cast<QScreen*>(screen), x, y);
}

void QCursor_QCursor_SetPos3(void* p)
{
	QCursor::setPos(*static_cast<QPoint*>(p));
}

void QCursor_QCursor_SetPos(int x, int y)
{
	QCursor::setPos(x, y);
}

void QCursor_SetShape(void* ptr, long long shape)
{
	static_cast<QCursor*>(ptr)->setShape(static_cast<Qt::CursorShape>(shape));
}

void QCursor_Swap(void* ptr, void* other)
{
	static_cast<QCursor*>(ptr)->swap(*static_cast<QCursor*>(other));
}

void QCursor_DestroyQCursor(void* ptr)
{
	static_cast<QCursor*>(ptr)->~QCursor();
}

void* QCursor_Pixmap(void* ptr)
{
	return new QPixmap(static_cast<QCursor*>(ptr)->pixmap());
}

void* QCursor_HotSpot(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QCursor*>(ptr)->hotSpot(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

long long QCursor_Shape(void* ptr)
{
	return static_cast<QCursor*>(ptr)->shape();
}

void* QCursor_Bitmap(void* ptr)
{
	return const_cast<QBitmap*>(static_cast<QCursor*>(ptr)->bitmap());
}

void* QCursor_Mask(void* ptr)
{
	return const_cast<QBitmap*>(static_cast<QCursor*>(ptr)->mask());
}

char QDesktopServices_QDesktopServices_OpenUrl(void* url)
{
	return QDesktopServices::openUrl(*static_cast<QUrl*>(url));
}

void QDesktopServices_QDesktopServices_SetUrlHandler(char* scheme, void* receiver, char* method)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(receiver))) {
		QDesktopServices::setUrlHandler(QString(scheme), static_cast<QOffscreenSurface*>(receiver), const_cast<const char*>(method));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(receiver))) {
		QDesktopServices::setUrlHandler(QString(scheme), static_cast<QPaintDeviceWindow*>(receiver), const_cast<const char*>(method));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(receiver))) {
		QDesktopServices::setUrlHandler(QString(scheme), static_cast<QPdfWriter*>(receiver), const_cast<const char*>(method));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(receiver))) {
		QDesktopServices::setUrlHandler(QString(scheme), static_cast<QWindow*>(receiver), const_cast<const char*>(method));
	} else {
		QDesktopServices::setUrlHandler(QString(scheme), static_cast<QObject*>(receiver), const_cast<const char*>(method));
	}
}

void QDesktopServices_QDesktopServices_UnsetUrlHandler(char* scheme)
{
	QDesktopServices::unsetUrlHandler(QString(scheme));
}

class MyQDoubleValidator: public QDoubleValidator
{
public:
	MyQDoubleValidator(QObject *parent) : QDoubleValidator(parent) {};
	MyQDoubleValidator(double bottom, double top, int decimals, QObject *parent) : QDoubleValidator(bottom, top, decimals, parent) {};
	void setRange(double minimum, double maximum, int decimals) { callbackQDoubleValidator_SetRange(this, minimum, maximum, decimals); };
	QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQDoubleValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
	void Signal_Changed() { callbackQValidator_Changed(this); };
	void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	bool event(QEvent * e) { return callbackQValidator_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQValidator_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQValidator_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQValidator_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQValidator_CustomEvent(this, event); };
	void deleteLater() { callbackQValidator_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQValidator_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQValidator_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQValidator_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQValidator_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQValidator_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QDoubleValidator_NewQDoubleValidator(void* parent)
{
	return new MyQDoubleValidator(static_cast<QObject*>(parent));
}

void* QDoubleValidator_NewQDoubleValidator2(double bottom, double top, int decimals, void* parent)
{
	return new MyQDoubleValidator(bottom, top, decimals, static_cast<QObject*>(parent));
}

void QDoubleValidator_SetBottom(void* ptr, double vdo)
{
	static_cast<QDoubleValidator*>(ptr)->setBottom(vdo);
}

void QDoubleValidator_SetDecimals(void* ptr, int vin)
{
	static_cast<QDoubleValidator*>(ptr)->setDecimals(vin);
}

void QDoubleValidator_SetNotation(void* ptr, long long vno)
{
	static_cast<QDoubleValidator*>(ptr)->setNotation(static_cast<QDoubleValidator::Notation>(vno));
}

void QDoubleValidator_SetRange(void* ptr, double minimum, double maximum, int decimals)
{
	static_cast<QDoubleValidator*>(ptr)->setRange(minimum, maximum, decimals);
}

void QDoubleValidator_SetRangeDefault(void* ptr, double minimum, double maximum, int decimals)
{
		static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::setRange(minimum, maximum, decimals);
}

void QDoubleValidator_SetTop(void* ptr, double vdo)
{
	static_cast<QDoubleValidator*>(ptr)->setTop(vdo);
}

void QDoubleValidator_DestroyQDoubleValidator(void* ptr)
{
	static_cast<QDoubleValidator*>(ptr)->~QDoubleValidator();
}

long long QDoubleValidator_Notation(void* ptr)
{
	return static_cast<QDoubleValidator*>(ptr)->notation();
}

long long QDoubleValidator_Validate(void* ptr, char* input, int pos)
{
	return static_cast<QDoubleValidator*>(ptr)->validate(*(new QString(input)), pos);
}

long long QDoubleValidator_ValidateDefault(void* ptr, char* input, int pos)
{
		return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::validate(*(new QString(input)), pos);
}

double QDoubleValidator_Bottom(void* ptr)
{
	return static_cast<QDoubleValidator*>(ptr)->bottom();
}

double QDoubleValidator_Top(void* ptr)
{
	return static_cast<QDoubleValidator*>(ptr)->top();
}

int QDoubleValidator_Decimals(void* ptr)
{
	return static_cast<QDoubleValidator*>(ptr)->decimals();
}

class MyQDrag: public QDrag
{
public:
	MyQDrag(QObject *dragSource) : QDrag(dragSource) {};
	void Signal_ActionChanged(Qt::DropAction action) { callbackQDrag_ActionChanged(this, action); };
	void Signal_TargetChanged(QObject * newTarget) { callbackQDrag_TargetChanged(this, newTarget); };
	bool event(QEvent * e) { return callbackQDrag_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQDrag_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQDrag_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQDrag_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQDrag_CustomEvent(this, event); };
	void deleteLater() { callbackQDrag_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQDrag_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQDrag_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQDrag_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQDrag_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDrag_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QDrag_NewQDrag(void* dragSource)
{
	return new MyQDrag(static_cast<QObject*>(dragSource));
}

long long QDrag_Exec(void* ptr, long long supportedActions)
{
	return static_cast<QDrag*>(ptr)->exec(static_cast<Qt::DropAction>(supportedActions));
}

long long QDrag_Exec2(void* ptr, long long supportedActions, long long defaultDropAction)
{
	return static_cast<QDrag*>(ptr)->exec(static_cast<Qt::DropAction>(supportedActions), static_cast<Qt::DropAction>(defaultDropAction));
}

void QDrag_ConnectActionChanged(void* ptr)
{
	QObject::connect(static_cast<QDrag*>(ptr), static_cast<void (QDrag::*)(Qt::DropAction)>(&QDrag::actionChanged), static_cast<MyQDrag*>(ptr), static_cast<void (MyQDrag::*)(Qt::DropAction)>(&MyQDrag::Signal_ActionChanged));
}

void QDrag_DisconnectActionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDrag*>(ptr), static_cast<void (QDrag::*)(Qt::DropAction)>(&QDrag::actionChanged), static_cast<MyQDrag*>(ptr), static_cast<void (MyQDrag::*)(Qt::DropAction)>(&MyQDrag::Signal_ActionChanged));
}

void QDrag_ActionChanged(void* ptr, long long action)
{
	static_cast<QDrag*>(ptr)->actionChanged(static_cast<Qt::DropAction>(action));
}

void QDrag_QDrag_Cancel()
{
	QDrag::cancel();
}

void QDrag_SetDragCursor(void* ptr, void* cursor, long long action)
{
	static_cast<QDrag*>(ptr)->setDragCursor(*static_cast<QPixmap*>(cursor), static_cast<Qt::DropAction>(action));
}

void QDrag_SetHotSpot(void* ptr, void* hotspot)
{
	static_cast<QDrag*>(ptr)->setHotSpot(*static_cast<QPoint*>(hotspot));
}

void QDrag_SetMimeData(void* ptr, void* data)
{
	static_cast<QDrag*>(ptr)->setMimeData(static_cast<QMimeData*>(data));
}

void QDrag_SetPixmap(void* ptr, void* pixmap)
{
	static_cast<QDrag*>(ptr)->setPixmap(*static_cast<QPixmap*>(pixmap));
}

void QDrag_ConnectTargetChanged(void* ptr)
{
	QObject::connect(static_cast<QDrag*>(ptr), static_cast<void (QDrag::*)(QObject *)>(&QDrag::targetChanged), static_cast<MyQDrag*>(ptr), static_cast<void (MyQDrag::*)(QObject *)>(&MyQDrag::Signal_TargetChanged));
}

void QDrag_DisconnectTargetChanged(void* ptr)
{
	QObject::disconnect(static_cast<QDrag*>(ptr), static_cast<void (QDrag::*)(QObject *)>(&QDrag::targetChanged), static_cast<MyQDrag*>(ptr), static_cast<void (MyQDrag::*)(QObject *)>(&MyQDrag::Signal_TargetChanged));
}

void QDrag_TargetChanged(void* ptr, void* newTarget)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(newTarget))) {
		static_cast<QDrag*>(ptr)->targetChanged(static_cast<QOffscreenSurface*>(newTarget));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(newTarget))) {
		static_cast<QDrag*>(ptr)->targetChanged(static_cast<QPaintDeviceWindow*>(newTarget));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(newTarget))) {
		static_cast<QDrag*>(ptr)->targetChanged(static_cast<QPdfWriter*>(newTarget));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(newTarget))) {
		static_cast<QDrag*>(ptr)->targetChanged(static_cast<QWindow*>(newTarget));
	} else {
		static_cast<QDrag*>(ptr)->targetChanged(static_cast<QObject*>(newTarget));
	}
}

void QDrag_DestroyQDrag(void* ptr)
{
	static_cast<QDrag*>(ptr)->~QDrag();
}

void* QDrag_MimeData(void* ptr)
{
	return static_cast<QDrag*>(ptr)->mimeData();
}

void* QDrag_Source(void* ptr)
{
	return static_cast<QDrag*>(ptr)->source();
}

void* QDrag_Target(void* ptr)
{
	return static_cast<QDrag*>(ptr)->target();
}

void* QDrag_DragCursor(void* ptr, long long action)
{
	return new QPixmap(static_cast<QDrag*>(ptr)->dragCursor(static_cast<Qt::DropAction>(action)));
}

void* QDrag_Pixmap(void* ptr)
{
	return new QPixmap(static_cast<QDrag*>(ptr)->pixmap());
}

void* QDrag_HotSpot(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QDrag*>(ptr)->hotSpot(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

long long QDrag_DefaultAction(void* ptr)
{
	return static_cast<QDrag*>(ptr)->defaultAction();
}

long long QDrag_SupportedActions(void* ptr)
{
	return static_cast<QDrag*>(ptr)->supportedActions();
}

void* QDrag___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QDrag___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QDrag___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QDrag___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QDrag___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QDrag___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QDrag___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QDrag___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QDrag___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QDrag___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QDrag___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QDrag___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QDrag___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QDrag___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QDrag___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QDrag_EventDefault(void* ptr, void* e)
{
		return static_cast<QDrag*>(ptr)->QDrag::event(static_cast<QEvent*>(e));
}

char QDrag_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QDrag*>(ptr)->QDrag::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QDrag*>(ptr)->QDrag::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QDrag*>(ptr)->QDrag::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QDrag*>(ptr)->QDrag::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QDrag*>(ptr)->QDrag::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QDrag_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QDrag*>(ptr)->QDrag::childEvent(static_cast<QChildEvent*>(event));
}

void QDrag_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QDrag*>(ptr)->QDrag::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QDrag_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QDrag*>(ptr)->QDrag::customEvent(static_cast<QEvent*>(event));
}

void QDrag_DeleteLaterDefault(void* ptr)
{
		static_cast<QDrag*>(ptr)->QDrag::deleteLater();
}

void QDrag_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QDrag*>(ptr)->QDrag::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QDrag_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QDrag*>(ptr)->QDrag::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QDrag_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QDrag*>(ptr)->QDrag::metaObject());
}

class MyQDragEnterEvent: public QDragEnterEvent
{
public:
	MyQDragEnterEvent(const QPoint &point, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) : QDragEnterEvent(point, actions, data, buttons, modifiers) {};
};

void* QDragEnterEvent_NewQDragEnterEvent(void* point, long long actions, void* data, long long buttons, long long modifiers)
{
	return new MyQDragEnterEvent(*static_cast<QPoint*>(point), static_cast<Qt::DropAction>(actions), static_cast<QMimeData*>(data), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers));
}

class MyQDragLeaveEvent: public QDragLeaveEvent
{
public:
	MyQDragLeaveEvent() : QDragLeaveEvent() {};
};

void* QDragLeaveEvent_NewQDragLeaveEvent()
{
	return new MyQDragLeaveEvent();
}

class MyQDragMoveEvent: public QDragMoveEvent
{
public:
	MyQDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type) : QDragMoveEvent(pos, actions, data, buttons, modifiers, type) {};
};

void* QDragMoveEvent_NewQDragMoveEvent(void* pos, long long actions, void* data, long long buttons, long long modifiers, long long ty)
{
	return new MyQDragMoveEvent(*static_cast<QPoint*>(pos), static_cast<Qt::DropAction>(actions), static_cast<QMimeData*>(data), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<QEvent::Type>(ty));
}

void QDragMoveEvent_Accept(void* ptr, void* rectangle)
{
	static_cast<QDragMoveEvent*>(ptr)->accept(*static_cast<QRect*>(rectangle));
}

void QDragMoveEvent_Ignore(void* ptr, void* rectangle)
{
	static_cast<QDragMoveEvent*>(ptr)->ignore(*static_cast<QRect*>(rectangle));
}

void QDragMoveEvent_DestroyQDragMoveEvent(void* ptr)
{
	static_cast<QDragMoveEvent*>(ptr)->~QDragMoveEvent();
}

void* QDragMoveEvent_AnswerRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QDragMoveEvent*>(ptr)->answerRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QDragMoveEvent_Rect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QDragMoveEvent*>(ptr)->rect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QDragMoveEvent_SetRect(void* ptr, void* vqr)
{
	static_cast<QDragMoveEvent*>(ptr)->rect = *static_cast<QRect*>(vqr);
}

class MyQDropEvent: public QDropEvent
{
public:
	MyQDropEvent(const QPointF &pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type) : QDropEvent(pos, actions, data, buttons, modifiers, type) {};
};

void* QDropEvent_NewQDropEvent(void* pos, long long actions, void* data, long long buttons, long long modifiers, long long ty)
{
	return new MyQDropEvent(*static_cast<QPointF*>(pos), static_cast<Qt::DropAction>(actions), static_cast<QMimeData*>(data), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<QEvent::Type>(ty));
}

void QDropEvent_AcceptProposedAction(void* ptr)
{
	static_cast<QDropEvent*>(ptr)->acceptProposedAction();
}

void QDropEvent_SetDropAction(void* ptr, long long action)
{
	static_cast<QDropEvent*>(ptr)->setDropAction(static_cast<Qt::DropAction>(action));
}

void* QDropEvent_Source(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->source();
}

void* QDropEvent_Pos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QDropEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

long long QDropEvent_DropAction(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->dropAction();
}

long long QDropEvent_ProposedAction(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->proposedAction();
}

long long QDropEvent_PossibleActions(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->possibleActions();
}

long long QDropEvent_KeyboardModifiers(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->keyboardModifiers();
}

long long QDropEvent_MouseButtons(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->mouseButtons();
}

void* QDropEvent_MimeData(void* ptr)
{
	return const_cast<QMimeData*>(static_cast<QDropEvent*>(ptr)->mimeData());
}

void* QDropEvent_PosF(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QDropEvent*>(ptr)->posF());
}

long long QDropEvent_Act(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->act;
}

void QDropEvent_SetAct(void* ptr, long long vqt)
{
	static_cast<QDropEvent*>(ptr)->act = static_cast<Qt::DropAction>(vqt);
}

long long QDropEvent_Default_action(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->default_action;
}

void QDropEvent_SetDefault_action(void* ptr, long long vqt)
{
	static_cast<QDropEvent*>(ptr)->default_action = static_cast<Qt::DropAction>(vqt);
}

long long QDropEvent_Drop_action(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->drop_action;
}

void QDropEvent_SetDrop_action(void* ptr, long long vqt)
{
	static_cast<QDropEvent*>(ptr)->drop_action = static_cast<Qt::DropAction>(vqt);
}

void* QDropEvent_Mdata(void* ptr)
{
	return const_cast<QMimeData*>(static_cast<QDropEvent*>(ptr)->mdata);
}

long long QDropEvent_ModState(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->modState;
}

void QDropEvent_SetModState(void* ptr, long long vqt)
{
	static_cast<QDropEvent*>(ptr)->modState = static_cast<Qt::KeyboardModifier>(vqt);
}

long long QDropEvent_MouseState(void* ptr)
{
	return static_cast<QDropEvent*>(ptr)->mouseState;
}

void QDropEvent_SetMouseState(void* ptr, long long vqt)
{
	static_cast<QDropEvent*>(ptr)->mouseState = static_cast<Qt::MouseButton>(vqt);
}

void* QDropEvent_P(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QDropEvent*>(ptr)->p; new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QDropEvent_SetP(void* ptr, void* vqp)
{
	static_cast<QDropEvent*>(ptr)->p = *static_cast<QPointF*>(vqp);
}

class MyQEnterEvent: public QEnterEvent
{
public:
	MyQEnterEvent(const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos) : QEnterEvent(localPos, windowPos, screenPos) {};
};

void* QEnterEvent_NewQEnterEvent(void* localPos, void* windowPos, void* screenPos)
{
	return new MyQEnterEvent(*static_cast<QPointF*>(localPos), *static_cast<QPointF*>(windowPos), *static_cast<QPointF*>(screenPos));
}

void* QEnterEvent_GlobalPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QEnterEvent*>(ptr)->globalPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QEnterEvent_Pos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QEnterEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QEnterEvent_LocalPos(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QEnterEvent*>(ptr)->localPos());
}

void* QEnterEvent_ScreenPos(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QEnterEvent*>(ptr)->screenPos());
}

void* QEnterEvent_WindowPos(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QEnterEvent*>(ptr)->windowPos());
}

int QEnterEvent_GlobalX(void* ptr)
{
	return static_cast<QEnterEvent*>(ptr)->globalX();
}

int QEnterEvent_GlobalY(void* ptr)
{
	return static_cast<QEnterEvent*>(ptr)->globalY();
}

int QEnterEvent_X(void* ptr)
{
	return static_cast<QEnterEvent*>(ptr)->x();
}

int QEnterEvent_Y(void* ptr)
{
	return static_cast<QEnterEvent*>(ptr)->y();
}

class MyQExposeEvent: public QExposeEvent
{
public:
	MyQExposeEvent(const QRegion &exposeRegion) : QExposeEvent(exposeRegion) {};
};

void* QExposeEvent_NewQExposeEvent(void* exposeRegion)
{
	return new MyQExposeEvent(*static_cast<QRegion*>(exposeRegion));
}

void* QExposeEvent_Region(void* ptr)
{
	return const_cast<QRegion*>(&static_cast<QExposeEvent*>(ptr)->region());
}

void* QExposeEvent_Rgn(void* ptr)
{
	return new QRegion(static_cast<QExposeEvent*>(ptr)->rgn);
}

void QExposeEvent_SetRgn(void* ptr, void* vqr)
{
	static_cast<QExposeEvent*>(ptr)->rgn = *static_cast<QRegion*>(vqr);
}

class MyQFileOpenEvent: public QFileOpenEvent
{
public:
};

struct QtGui_PackedString QFileOpenEvent_File(void* ptr)
{
	return ({ QByteArray t25f76f = static_cast<QFileOpenEvent*>(ptr)->file().toUtf8(); QtGui_PackedString { const_cast<char*>(t25f76f.prepend("WHITESPACE").constData()+10), t25f76f.size()-10 }; });
}

void* QFileOpenEvent_Url(void* ptr)
{
	return new QUrl(static_cast<QFileOpenEvent*>(ptr)->url());
}

char QFileOpenEvent_OpenFile(void* ptr, void* file, long long flags)
{
	return static_cast<QFileOpenEvent*>(ptr)->openFile(*static_cast<QFile*>(file), static_cast<QIODevice::OpenModeFlag>(flags));
}

class MyQFocusEvent: public QFocusEvent
{
public:
	MyQFocusEvent(Type type, Qt::FocusReason reason) : QFocusEvent(type, reason) {};
};

void* QFocusEvent_NewQFocusEvent(long long ty, long long reason)
{
	return new MyQFocusEvent(static_cast<QEvent::Type>(ty), static_cast<Qt::FocusReason>(reason));
}

long long QFocusEvent_Reason(void* ptr)
{
	return static_cast<QFocusEvent*>(ptr)->reason();
}

char QFocusEvent_GotFocus(void* ptr)
{
	return static_cast<QFocusEvent*>(ptr)->gotFocus();
}

char QFocusEvent_LostFocus(void* ptr)
{
	return static_cast<QFocusEvent*>(ptr)->lostFocus();
}

int QFont_Times_Type()
{
	return QFont::Times;
}

int QFont_Courier_Type()
{
	return QFont::Courier;
}

int QFont_OldEnglish_Type()
{
	return QFont::OldEnglish;
}

int QFont_System_Type()
{
	return QFont::System;
}

int QFont_AnyStyle_Type()
{
	return QFont::AnyStyle;
}

int QFont_Cursive_Type()
{
	return QFont::Cursive;
}

int QFont_Monospace_Type()
{
	return QFont::Monospace;
}

int QFont_Fantasy_Type()
{
	return QFont::Fantasy;
}

void* QFont_NewQFont()
{
	return new QFont();
}

void* QFont_NewQFont4(void* font)
{
	return new QFont(*static_cast<QFont*>(font));
}

void* QFont_NewQFont3(void* font, void* pd)
{
	return new QFont(*static_cast<QFont*>(font), static_cast<QPaintDevice*>(pd));
}

void* QFont_NewQFont2(char* family, int pointSize, int weight, char italic)
{
	return new QFont(QString(family), pointSize, weight, italic != 0);
}

struct QtGui_PackedString QFont_QFont_Substitute(char* familyName)
{
	return ({ QByteArray te7e766 = QFont::substitute(QString(familyName)).toUtf8(); QtGui_PackedString { const_cast<char*>(te7e766.prepend("WHITESPACE").constData()+10), te7e766.size()-10 }; });
}

struct QtGui_PackedString QFont_QFont_Substitutes(char* familyName)
{
	return ({ QByteArray t0713c5 = QFont::substitutes(QString(familyName)).join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t0713c5.prepend("WHITESPACE").constData()+10), t0713c5.size()-10 }; });
}

struct QtGui_PackedString QFont_QFont_Substitutions()
{
	return ({ QByteArray t300c5a = QFont::substitutions().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t300c5a.prepend("WHITESPACE").constData()+10), t300c5a.size()-10 }; });
}

char QFont_FromString(void* ptr, char* descrip)
{
	return static_cast<QFont*>(ptr)->fromString(QString(descrip));
}

void QFont_QFont_InsertSubstitution(char* familyName, char* substituteName)
{
	QFont::insertSubstitution(QString(familyName), QString(substituteName));
}

void QFont_QFont_InsertSubstitutions(char* familyName, char* substituteNames)
{
	QFont::insertSubstitutions(QString(familyName), QString(substituteNames).split("|", QString::SkipEmptyParts));
}

void QFont_QFont_RemoveSubstitutions(char* familyName)
{
	QFont::removeSubstitutions(QString(familyName));
}

void QFont_SetBold(void* ptr, char enable)
{
	static_cast<QFont*>(ptr)->setBold(enable != 0);
}

void QFont_SetCapitalization(void* ptr, long long caps)
{
	static_cast<QFont*>(ptr)->setCapitalization(static_cast<QFont::Capitalization>(caps));
}

void QFont_SetFamily(void* ptr, char* family)
{
	static_cast<QFont*>(ptr)->setFamily(QString(family));
}

void QFont_SetFixedPitch(void* ptr, char enable)
{
	static_cast<QFont*>(ptr)->setFixedPitch(enable != 0);
}

void QFont_SetHintingPreference(void* ptr, long long hintingPreference)
{
	static_cast<QFont*>(ptr)->setHintingPreference(static_cast<QFont::HintingPreference>(hintingPreference));
}

void QFont_SetItalic(void* ptr, char enable)
{
	static_cast<QFont*>(ptr)->setItalic(enable != 0);
}

void QFont_SetKerning(void* ptr, char enable)
{
	static_cast<QFont*>(ptr)->setKerning(enable != 0);
}

void QFont_SetLetterSpacing(void* ptr, long long ty, double spacing)
{
	static_cast<QFont*>(ptr)->setLetterSpacing(static_cast<QFont::SpacingType>(ty), spacing);
}

void QFont_SetOverline(void* ptr, char enable)
{
	static_cast<QFont*>(ptr)->setOverline(enable != 0);
}

void QFont_SetPixelSize(void* ptr, int pixelSize)
{
	static_cast<QFont*>(ptr)->setPixelSize(pixelSize);
}

void QFont_SetPointSize(void* ptr, int pointSize)
{
	static_cast<QFont*>(ptr)->setPointSize(pointSize);
}

void QFont_SetPointSizeF(void* ptr, double pointSize)
{
	static_cast<QFont*>(ptr)->setPointSizeF(pointSize);
}

void QFont_SetStretch(void* ptr, int factor)
{
	static_cast<QFont*>(ptr)->setStretch(factor);
}

void QFont_SetStrikeOut(void* ptr, char enable)
{
	static_cast<QFont*>(ptr)->setStrikeOut(enable != 0);
}

void QFont_SetStyle(void* ptr, long long style)
{
	static_cast<QFont*>(ptr)->setStyle(static_cast<QFont::Style>(style));
}

void QFont_SetStyleHint(void* ptr, long long hint, long long strategy)
{
	static_cast<QFont*>(ptr)->setStyleHint(static_cast<QFont::StyleHint>(hint), static_cast<QFont::StyleStrategy>(strategy));
}

void QFont_SetStyleName(void* ptr, char* styleName)
{
	static_cast<QFont*>(ptr)->setStyleName(QString(styleName));
}

void QFont_SetStyleStrategy(void* ptr, long long s)
{
	static_cast<QFont*>(ptr)->setStyleStrategy(static_cast<QFont::StyleStrategy>(s));
}

void QFont_SetUnderline(void* ptr, char enable)
{
	static_cast<QFont*>(ptr)->setUnderline(enable != 0);
}

void QFont_SetWeight(void* ptr, int weight)
{
	static_cast<QFont*>(ptr)->setWeight(weight);
}

void QFont_SetWordSpacing(void* ptr, double spacing)
{
	static_cast<QFont*>(ptr)->setWordSpacing(spacing);
}

void QFont_Swap(void* ptr, void* other)
{
	static_cast<QFont*>(ptr)->swap(*static_cast<QFont*>(other));
}

void QFont_DestroyQFont(void* ptr)
{
	static_cast<QFont*>(ptr)->~QFont();
}

long long QFont_Capitalization(void* ptr)
{
	return static_cast<QFont*>(ptr)->capitalization();
}

long long QFont_HintingPreference(void* ptr)
{
	return static_cast<QFont*>(ptr)->hintingPreference();
}

void* QFont_Resolve(void* ptr, void* other)
{
	return new QFont(static_cast<QFont*>(ptr)->resolve(*static_cast<QFont*>(other)));
}

struct QtGui_PackedString QFont_DefaultFamily(void* ptr)
{
	return ({ QByteArray t141ea0 = static_cast<QFont*>(ptr)->defaultFamily().toUtf8(); QtGui_PackedString { const_cast<char*>(t141ea0.prepend("WHITESPACE").constData()+10), t141ea0.size()-10 }; });
}

struct QtGui_PackedString QFont_Family(void* ptr)
{
	return ({ QByteArray t52247e = static_cast<QFont*>(ptr)->family().toUtf8(); QtGui_PackedString { const_cast<char*>(t52247e.prepend("WHITESPACE").constData()+10), t52247e.size()-10 }; });
}

struct QtGui_PackedString QFont_Key(void* ptr)
{
	return ({ QByteArray t9324a4 = static_cast<QFont*>(ptr)->key().toUtf8(); QtGui_PackedString { const_cast<char*>(t9324a4.prepend("WHITESPACE").constData()+10), t9324a4.size()-10 }; });
}

struct QtGui_PackedString QFont_LastResortFamily(void* ptr)
{
	return ({ QByteArray t483f1f = static_cast<QFont*>(ptr)->lastResortFamily().toUtf8(); QtGui_PackedString { const_cast<char*>(t483f1f.prepend("WHITESPACE").constData()+10), t483f1f.size()-10 }; });
}

struct QtGui_PackedString QFont_LastResortFont(void* ptr)
{
	return ({ QByteArray td93362 = static_cast<QFont*>(ptr)->lastResortFont().toUtf8(); QtGui_PackedString { const_cast<char*>(td93362.prepend("WHITESPACE").constData()+10), td93362.size()-10 }; });
}

struct QtGui_PackedString QFont_StyleName(void* ptr)
{
	return ({ QByteArray t8d3474 = static_cast<QFont*>(ptr)->styleName().toUtf8(); QtGui_PackedString { const_cast<char*>(t8d3474.prepend("WHITESPACE").constData()+10), t8d3474.size()-10 }; });
}

struct QtGui_PackedString QFont_ToString(void* ptr)
{
	return ({ QByteArray t32ab86 = static_cast<QFont*>(ptr)->toString().toUtf8(); QtGui_PackedString { const_cast<char*>(t32ab86.prepend("WHITESPACE").constData()+10), t32ab86.size()-10 }; });
}

long long QFont_LetterSpacingType(void* ptr)
{
	return static_cast<QFont*>(ptr)->letterSpacingType();
}

long long QFont_Style(void* ptr)
{
	return static_cast<QFont*>(ptr)->style();
}

long long QFont_StyleHint(void* ptr)
{
	return static_cast<QFont*>(ptr)->styleHint();
}

long long QFont_StyleStrategy(void* ptr)
{
	return static_cast<QFont*>(ptr)->styleStrategy();
}

char QFont_Bold(void* ptr)
{
	return static_cast<QFont*>(ptr)->bold();
}

char QFont_ExactMatch(void* ptr)
{
	return static_cast<QFont*>(ptr)->exactMatch();
}

char QFont_FixedPitch(void* ptr)
{
	return static_cast<QFont*>(ptr)->fixedPitch();
}

char QFont_IsCopyOf(void* ptr, void* f)
{
	return static_cast<QFont*>(ptr)->isCopyOf(*static_cast<QFont*>(f));
}

char QFont_Italic(void* ptr)
{
	return static_cast<QFont*>(ptr)->italic();
}

char QFont_Kerning(void* ptr)
{
	return static_cast<QFont*>(ptr)->kerning();
}

char QFont_Overline(void* ptr)
{
	return static_cast<QFont*>(ptr)->overline();
}

char QFont_StrikeOut(void* ptr)
{
	return static_cast<QFont*>(ptr)->strikeOut();
}

char QFont_Underline(void* ptr)
{
	return static_cast<QFont*>(ptr)->underline();
}

int QFont_PixelSize(void* ptr)
{
	return static_cast<QFont*>(ptr)->pixelSize();
}

int QFont_PointSize(void* ptr)
{
	return static_cast<QFont*>(ptr)->pointSize();
}

int QFont_Stretch(void* ptr)
{
	return static_cast<QFont*>(ptr)->stretch();
}

int QFont_Weight(void* ptr)
{
	return static_cast<QFont*>(ptr)->weight();
}

double QFont_LetterSpacing(void* ptr)
{
	return static_cast<QFont*>(ptr)->letterSpacing();
}

double QFont_PointSizeF(void* ptr)
{
	return static_cast<QFont*>(ptr)->pointSizeF();
}

double QFont_WordSpacing(void* ptr)
{
	return static_cast<QFont*>(ptr)->wordSpacing();
}

void* QFont_ToVariant(void* ptr)
{
	return new QVariant(*static_cast<QFont*>(ptr));
}

int QFontDatabase_Ogham_Type()
{
	return QFontDatabase::Ogham;
}

int QFontDatabase_Runic_Type()
{
	return QFontDatabase::Runic;
}

int QFontDatabase_Nko_Type()
{
	return QFontDatabase::Nko;
}

int QFontDatabase_WritingSystemsCount_Type()
{
	return QFontDatabase::WritingSystemsCount;
}

struct QtGui_PackedList QFontDatabase_PointSizes(void* ptr, char* family, char* styleName)
{
	return ({ QList<int>* tmpValue = new QList<int>(static_cast<QFontDatabase*>(ptr)->pointSizes(QString(family), QString(styleName))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QFontDatabase_SmoothSizes(void* ptr, char* family, char* styleName)
{
	return ({ QList<int>* tmpValue = new QList<int>(static_cast<QFontDatabase*>(ptr)->smoothSizes(QString(family), QString(styleName))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

char QFontDatabase_QFontDatabase_RemoveAllApplicationFonts()
{
	return QFontDatabase::removeAllApplicationFonts();
}

char QFontDatabase_QFontDatabase_RemoveApplicationFont(int id)
{
	return QFontDatabase::removeApplicationFont(id);
}

void* QFontDatabase_QFontDatabase_SystemFont(long long ty)
{
	return new QFont(QFontDatabase::systemFont(static_cast<QFontDatabase::SystemFont>(ty)));
}

void* QFontDatabase_NewQFontDatabase()
{
	return new QFontDatabase();
}

struct QtGui_PackedList QFontDatabase_QFontDatabase_StandardSizes()
{
	return ({ QList<int>* tmpValue = new QList<int>(QFontDatabase::standardSizes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedString QFontDatabase_StyleString(void* ptr, void* font)
{
	return ({ QByteArray tdc7da2 = static_cast<QFontDatabase*>(ptr)->styleString(*static_cast<QFont*>(font)).toUtf8(); QtGui_PackedString { const_cast<char*>(tdc7da2.prepend("WHITESPACE").constData()+10), tdc7da2.size()-10 }; });
}

struct QtGui_PackedString QFontDatabase_StyleString2(void* ptr, void* fontInfo)
{
	return ({ QByteArray t17e039 = static_cast<QFontDatabase*>(ptr)->styleString(*static_cast<QFontInfo*>(fontInfo)).toUtf8(); QtGui_PackedString { const_cast<char*>(t17e039.prepend("WHITESPACE").constData()+10), t17e039.size()-10 }; });
}

struct QtGui_PackedString QFontDatabase_QFontDatabase_ApplicationFontFamilies(int id)
{
	return ({ QByteArray tf75c72 = QFontDatabase::applicationFontFamilies(id).join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(tf75c72.prepend("WHITESPACE").constData()+10), tf75c72.size()-10 }; });
}

int QFontDatabase_QFontDatabase_AddApplicationFont(char* fileName)
{
	return QFontDatabase::addApplicationFont(QString(fileName));
}

int QFontDatabase_QFontDatabase_AddApplicationFontFromData(void* fontData)
{
	return QFontDatabase::addApplicationFontFromData(*static_cast<QByteArray*>(fontData));
}

void* QFontDatabase_Font(void* ptr, char* family, char* style, int pointSize)
{
	return new QFont(static_cast<QFontDatabase*>(ptr)->font(QString(family), QString(style), pointSize));
}

struct QtGui_PackedString QFontDatabase_Families(void* ptr, long long writingSystem)
{
	return ({ QByteArray t8f80b0 = static_cast<QFontDatabase*>(ptr)->families(static_cast<QFontDatabase::WritingSystem>(writingSystem)).join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t8f80b0.prepend("WHITESPACE").constData()+10), t8f80b0.size()-10 }; });
}

struct QtGui_PackedString QFontDatabase_Styles(void* ptr, char* family)
{
	return ({ QByteArray td1fc82 = static_cast<QFontDatabase*>(ptr)->styles(QString(family)).join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(td1fc82.prepend("WHITESPACE").constData()+10), td1fc82.size()-10 }; });
}

char QFontDatabase_Bold(void* ptr, char* family, char* style)
{
	return static_cast<QFontDatabase*>(ptr)->bold(QString(family), QString(style));
}

char QFontDatabase_IsBitmapScalable(void* ptr, char* family, char* style)
{
	return static_cast<QFontDatabase*>(ptr)->isBitmapScalable(QString(family), QString(style));
}

char QFontDatabase_IsFixedPitch(void* ptr, char* family, char* style)
{
	return static_cast<QFontDatabase*>(ptr)->isFixedPitch(QString(family), QString(style));
}

char QFontDatabase_IsPrivateFamily(void* ptr, char* family)
{
	return static_cast<QFontDatabase*>(ptr)->isPrivateFamily(QString(family));
}

char QFontDatabase_IsScalable(void* ptr, char* family, char* style)
{
	return static_cast<QFontDatabase*>(ptr)->isScalable(QString(family), QString(style));
}

char QFontDatabase_IsSmoothlyScalable(void* ptr, char* family, char* style)
{
	return static_cast<QFontDatabase*>(ptr)->isSmoothlyScalable(QString(family), QString(style));
}

char QFontDatabase_Italic(void* ptr, char* family, char* style)
{
	return static_cast<QFontDatabase*>(ptr)->italic(QString(family), QString(style));
}

int QFontDatabase_Weight(void* ptr, char* family, char* style)
{
	return static_cast<QFontDatabase*>(ptr)->weight(QString(family), QString(style));
}

int QFontDatabase___pointSizes_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QFontDatabase___pointSizes_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QFontDatabase___pointSizes_newList(void* ptr)
{
	return new QList<int>;
}

int QFontDatabase___smoothSizes_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QFontDatabase___smoothSizes_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QFontDatabase___smoothSizes_newList(void* ptr)
{
	return new QList<int>;
}

int QFontDatabase___standardSizes_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QFontDatabase___standardSizes_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QFontDatabase___standardSizes_newList(void* ptr)
{
	return new QList<int>;
}

void* QFontInfo_NewQFontInfo(void* font)
{
	return new QFontInfo(*static_cast<QFont*>(font));
}

void* QFontInfo_NewQFontInfo2(void* fi)
{
	return new QFontInfo(*static_cast<QFontInfo*>(fi));
}

void QFontInfo_Swap(void* ptr, void* other)
{
	static_cast<QFontInfo*>(ptr)->swap(*static_cast<QFontInfo*>(other));
}

void QFontInfo_DestroyQFontInfo(void* ptr)
{
	static_cast<QFontInfo*>(ptr)->~QFontInfo();
}

long long QFontInfo_Style(void* ptr)
{
	return static_cast<QFontInfo*>(ptr)->style();
}

long long QFontInfo_StyleHint(void* ptr)
{
	return static_cast<QFontInfo*>(ptr)->styleHint();
}

struct QtGui_PackedString QFontInfo_Family(void* ptr)
{
	return ({ QByteArray t7b458f = static_cast<QFontInfo*>(ptr)->family().toUtf8(); QtGui_PackedString { const_cast<char*>(t7b458f.prepend("WHITESPACE").constData()+10), t7b458f.size()-10 }; });
}

struct QtGui_PackedString QFontInfo_StyleName(void* ptr)
{
	return ({ QByteArray t231b30 = static_cast<QFontInfo*>(ptr)->styleName().toUtf8(); QtGui_PackedString { const_cast<char*>(t231b30.prepend("WHITESPACE").constData()+10), t231b30.size()-10 }; });
}

char QFontInfo_Bold(void* ptr)
{
	return static_cast<QFontInfo*>(ptr)->bold();
}

char QFontInfo_ExactMatch(void* ptr)
{
	return static_cast<QFontInfo*>(ptr)->exactMatch();
}

char QFontInfo_FixedPitch(void* ptr)
{
	return static_cast<QFontInfo*>(ptr)->fixedPitch();
}

char QFontInfo_Italic(void* ptr)
{
	return static_cast<QFontInfo*>(ptr)->italic();
}

int QFontInfo_PixelSize(void* ptr)
{
	return static_cast<QFontInfo*>(ptr)->pixelSize();
}

int QFontInfo_PointSize(void* ptr)
{
	return static_cast<QFontInfo*>(ptr)->pointSize();
}

int QFontInfo_Weight(void* ptr)
{
	return static_cast<QFontInfo*>(ptr)->weight();
}

double QFontInfo_PointSizeF(void* ptr)
{
	return static_cast<QFontInfo*>(ptr)->pointSizeF();
}

void* QFontMetrics_NewQFontMetrics(void* font)
{
	return new QFontMetrics(*static_cast<QFont*>(font));
}

void* QFontMetrics_NewQFontMetrics2(void* font, void* paintdevice)
{
	return new QFontMetrics(*static_cast<QFont*>(font), static_cast<QPaintDevice*>(paintdevice));
}

void* QFontMetrics_NewQFontMetrics3(void* fm)
{
	return new QFontMetrics(*static_cast<QFontMetrics*>(fm));
}

void QFontMetrics_Swap(void* ptr, void* other)
{
	static_cast<QFontMetrics*>(ptr)->swap(*static_cast<QFontMetrics*>(other));
}

void QFontMetrics_DestroyQFontMetrics(void* ptr)
{
	static_cast<QFontMetrics*>(ptr)->~QFontMetrics();
}

void* QFontMetrics_BoundingRect(void* ptr, void* ch)
{
	return ({ QRect tmpValue = static_cast<QFontMetrics*>(ptr)->boundingRect(*static_cast<QChar*>(ch)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QFontMetrics_BoundingRect3(void* ptr, void* rect, int flags, char* text, int tabStops, int tabArray)
{
	return ({ QRect tmpValue = static_cast<QFontMetrics*>(ptr)->boundingRect(*static_cast<QRect*>(rect), flags, QString(text), tabStops, &tabArray); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QFontMetrics_BoundingRect2(void* ptr, char* text)
{
	return ({ QRect tmpValue = static_cast<QFontMetrics*>(ptr)->boundingRect(QString(text)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QFontMetrics_BoundingRect4(void* ptr, int x, int y, int width, int height, int flags, char* text, int tabStops, int tabArray)
{
	return ({ QRect tmpValue = static_cast<QFontMetrics*>(ptr)->boundingRect(x, y, width, height, flags, QString(text), tabStops, &tabArray); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QFontMetrics_TightBoundingRect(void* ptr, char* text)
{
	return ({ QRect tmpValue = static_cast<QFontMetrics*>(ptr)->tightBoundingRect(QString(text)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QFontMetrics_Size(void* ptr, int flags, char* text, int tabStops, int tabArray)
{
	return ({ QSize tmpValue = static_cast<QFontMetrics*>(ptr)->size(flags, QString(text), tabStops, &tabArray); new QSize(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QFontMetrics_ElidedText(void* ptr, char* text, long long mode, int width, int flags)
{
	return ({ QByteArray tc1c39a = static_cast<QFontMetrics*>(ptr)->elidedText(QString(text), static_cast<Qt::TextElideMode>(mode), width, flags).toUtf8(); QtGui_PackedString { const_cast<char*>(tc1c39a.prepend("WHITESPACE").constData()+10), tc1c39a.size()-10 }; });
}

char QFontMetrics_InFont(void* ptr, void* ch)
{
	return static_cast<QFontMetrics*>(ptr)->inFont(*static_cast<QChar*>(ch));
}

char QFontMetrics_InFontUcs4(void* ptr, unsigned int ucs4)
{
	return static_cast<QFontMetrics*>(ptr)->inFontUcs4(ucs4);
}

int QFontMetrics_Ascent(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->ascent();
}

int QFontMetrics_AverageCharWidth(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->averageCharWidth();
}

int QFontMetrics_CapHeight(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->capHeight();
}

int QFontMetrics_Descent(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->descent();
}

int QFontMetrics_Height(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->height();
}

int QFontMetrics_Leading(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->leading();
}

int QFontMetrics_LeftBearing(void* ptr, void* ch)
{
	return static_cast<QFontMetrics*>(ptr)->leftBearing(*static_cast<QChar*>(ch));
}

int QFontMetrics_LineSpacing(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->lineSpacing();
}

int QFontMetrics_LineWidth(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->lineWidth();
}

int QFontMetrics_MaxWidth(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->maxWidth();
}

int QFontMetrics_MinLeftBearing(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->minLeftBearing();
}

int QFontMetrics_MinRightBearing(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->minRightBearing();
}

int QFontMetrics_OverlinePos(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->overlinePos();
}

int QFontMetrics_RightBearing(void* ptr, void* ch)
{
	return static_cast<QFontMetrics*>(ptr)->rightBearing(*static_cast<QChar*>(ch));
}

int QFontMetrics_StrikeOutPos(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->strikeOutPos();
}

int QFontMetrics_UnderlinePos(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->underlinePos();
}

int QFontMetrics_Width3(void* ptr, void* ch)
{
	return static_cast<QFontMetrics*>(ptr)->width(*static_cast<QChar*>(ch));
}

int QFontMetrics_Width(void* ptr, char* text, int len)
{
	return static_cast<QFontMetrics*>(ptr)->width(QString(text), len);
}

int QFontMetrics_XHeight(void* ptr)
{
	return static_cast<QFontMetrics*>(ptr)->xHeight();
}

void* QFontMetricsF_NewQFontMetricsF(void* font)
{
	return new QFontMetricsF(*static_cast<QFont*>(font));
}

void* QFontMetricsF_NewQFontMetricsF2(void* font, void* paintdevice)
{
	return new QFontMetricsF(*static_cast<QFont*>(font), static_cast<QPaintDevice*>(paintdevice));
}

void* QFontMetricsF_NewQFontMetricsF3(void* fontMetrics)
{
	return new QFontMetricsF(*static_cast<QFontMetrics*>(fontMetrics));
}

void* QFontMetricsF_NewQFontMetricsF4(void* fm)
{
	return new QFontMetricsF(*static_cast<QFontMetricsF*>(fm));
}

void QFontMetricsF_Swap(void* ptr, void* other)
{
	static_cast<QFontMetricsF*>(ptr)->swap(*static_cast<QFontMetricsF*>(other));
}

void QFontMetricsF_DestroyQFontMetricsF(void* ptr)
{
	static_cast<QFontMetricsF*>(ptr)->~QFontMetricsF();
}

void* QFontMetricsF_BoundingRect2(void* ptr, void* ch)
{
	return ({ QRectF tmpValue = static_cast<QFontMetricsF*>(ptr)->boundingRect(*static_cast<QChar*>(ch)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QFontMetricsF_BoundingRect3(void* ptr, void* rect, int flags, char* text, int tabStops, int tabArray)
{
	return ({ QRectF tmpValue = static_cast<QFontMetricsF*>(ptr)->boundingRect(*static_cast<QRectF*>(rect), flags, QString(text), tabStops, &tabArray); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QFontMetricsF_BoundingRect(void* ptr, char* text)
{
	return ({ QRectF tmpValue = static_cast<QFontMetricsF*>(ptr)->boundingRect(QString(text)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QFontMetricsF_TightBoundingRect(void* ptr, char* text)
{
	return ({ QRectF tmpValue = static_cast<QFontMetricsF*>(ptr)->tightBoundingRect(QString(text)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QFontMetricsF_Size(void* ptr, int flags, char* text, int tabStops, int tabArray)
{
	return ({ QSizeF tmpValue = static_cast<QFontMetricsF*>(ptr)->size(flags, QString(text), tabStops, &tabArray); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QFontMetricsF_ElidedText(void* ptr, char* text, long long mode, double width, int flags)
{
	return ({ QByteArray teef6f9 = static_cast<QFontMetricsF*>(ptr)->elidedText(QString(text), static_cast<Qt::TextElideMode>(mode), width, flags).toUtf8(); QtGui_PackedString { const_cast<char*>(teef6f9.prepend("WHITESPACE").constData()+10), teef6f9.size()-10 }; });
}

char QFontMetricsF_InFont(void* ptr, void* ch)
{
	return static_cast<QFontMetricsF*>(ptr)->inFont(*static_cast<QChar*>(ch));
}

char QFontMetricsF_InFontUcs4(void* ptr, unsigned int ch)
{
	return static_cast<QFontMetricsF*>(ptr)->inFontUcs4(ch);
}

double QFontMetricsF_Ascent(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->ascent();
}

double QFontMetricsF_AverageCharWidth(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->averageCharWidth();
}

double QFontMetricsF_CapHeight(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->capHeight();
}

double QFontMetricsF_Descent(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->descent();
}

double QFontMetricsF_Height(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->height();
}

double QFontMetricsF_Leading(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->leading();
}

double QFontMetricsF_LeftBearing(void* ptr, void* ch)
{
	return static_cast<QFontMetricsF*>(ptr)->leftBearing(*static_cast<QChar*>(ch));
}

double QFontMetricsF_LineSpacing(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->lineSpacing();
}

double QFontMetricsF_LineWidth(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->lineWidth();
}

double QFontMetricsF_MaxWidth(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->maxWidth();
}

double QFontMetricsF_MinLeftBearing(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->minLeftBearing();
}

double QFontMetricsF_MinRightBearing(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->minRightBearing();
}

double QFontMetricsF_OverlinePos(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->overlinePos();
}

double QFontMetricsF_RightBearing(void* ptr, void* ch)
{
	return static_cast<QFontMetricsF*>(ptr)->rightBearing(*static_cast<QChar*>(ch));
}

double QFontMetricsF_StrikeOutPos(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->strikeOutPos();
}

double QFontMetricsF_UnderlinePos(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->underlinePos();
}

double QFontMetricsF_Width2(void* ptr, void* ch)
{
	return static_cast<QFontMetricsF*>(ptr)->width(*static_cast<QChar*>(ch));
}

double QFontMetricsF_Width(void* ptr, char* text)
{
	return static_cast<QFontMetricsF*>(ptr)->width(QString(text));
}

double QFontMetricsF_XHeight(void* ptr)
{
	return static_cast<QFontMetricsF*>(ptr)->xHeight();
}

class MyQGenericPlugin: public QGenericPlugin
{
public:
	MyQGenericPlugin(QObject *parent) : QGenericPlugin(parent) {};
	QObject * create(const QString & key, const QString & specification) { QByteArray ta62f22 = key.toUtf8(); QtGui_PackedString keyPacked = { const_cast<char*>(ta62f22.prepend("WHITESPACE").constData()+10), ta62f22.size()-10 };QByteArray t03d6a1 = specification.toUtf8(); QtGui_PackedString specificationPacked = { const_cast<char*>(t03d6a1.prepend("WHITESPACE").constData()+10), t03d6a1.size()-10 };return static_cast<QObject*>(callbackQGenericPlugin_Create(this, keyPacked, specificationPacked)); };
	bool event(QEvent * e) { return callbackQGenericPlugin_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGenericPlugin_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQGenericPlugin_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGenericPlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGenericPlugin_CustomEvent(this, event); };
	void deleteLater() { callbackQGenericPlugin_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGenericPlugin_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGenericPlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQGenericPlugin_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGenericPlugin_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGenericPlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QGenericPlugin_NewQGenericPlugin(void* parent)
{
	return new MyQGenericPlugin(static_cast<QObject*>(parent));
}

void* QGenericPlugin_Create(void* ptr, char* key, char* specification)
{
	return static_cast<QGenericPlugin*>(ptr)->create(QString(key), QString(specification));
}

void QGenericPlugin_DestroyQGenericPlugin(void* ptr)
{
	static_cast<QGenericPlugin*>(ptr)->~QGenericPlugin();
}

void* QGenericPlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QGenericPlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QGenericPlugin___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QGenericPlugin___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QGenericPlugin___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QGenericPlugin___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QGenericPlugin___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QGenericPlugin___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QGenericPlugin___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QGenericPlugin___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QGenericPlugin___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QGenericPlugin___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QGenericPlugin___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QGenericPlugin___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QGenericPlugin___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QGenericPlugin_EventDefault(void* ptr, void* e)
{
		return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::event(static_cast<QEvent*>(e));
}

char QGenericPlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QGenericPlugin_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::childEvent(static_cast<QChildEvent*>(event));
}

void QGenericPlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QGenericPlugin_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::customEvent(static_cast<QEvent*>(event));
}

void QGenericPlugin_DeleteLaterDefault(void* ptr)
{
		static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::deleteLater();
}

void QGenericPlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QGenericPlugin_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QGenericPlugin_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QGenericPlugin*>(ptr)->QGenericPlugin::metaObject());
}

void* QGenericPluginFactory_QGenericPluginFactory_Create(char* key, char* specification)
{
	return QGenericPluginFactory::create(QString(key), QString(specification));
}

struct QtGui_PackedString QGenericPluginFactory_QGenericPluginFactory_Keys()
{
	return ({ QByteArray t692cb7 = QGenericPluginFactory::keys().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t692cb7.prepend("WHITESPACE").constData()+10), t692cb7.size()-10 }; });
}

void* QGlyphRun_NewQGlyphRun()
{
	return new QGlyphRun();
}

void* QGlyphRun_NewQGlyphRun2(void* other)
{
	return new QGlyphRun(*static_cast<QGlyphRun*>(other));
}

void QGlyphRun_Clear(void* ptr)
{
	static_cast<QGlyphRun*>(ptr)->clear();
}

void QGlyphRun_SetBoundingRect(void* ptr, void* boundingRect)
{
	static_cast<QGlyphRun*>(ptr)->setBoundingRect(*static_cast<QRectF*>(boundingRect));
}

void QGlyphRun_SetFlag(void* ptr, long long flag, char enabled)
{
	static_cast<QGlyphRun*>(ptr)->setFlag(static_cast<QGlyphRun::GlyphRunFlag>(flag), enabled != 0);
}

void QGlyphRun_SetFlags(void* ptr, long long flags)
{
	static_cast<QGlyphRun*>(ptr)->setFlags(static_cast<QGlyphRun::GlyphRunFlag>(flags));
}

void QGlyphRun_SetGlyphIndexes(void* ptr, void* glyphIndexes)
{
	static_cast<QGlyphRun*>(ptr)->setGlyphIndexes(*static_cast<QVector<quint32>*>(glyphIndexes));
}

void QGlyphRun_SetOverline(void* ptr, char overline)
{
	static_cast<QGlyphRun*>(ptr)->setOverline(overline != 0);
}

void QGlyphRun_SetPositions(void* ptr, void* positions)
{
	static_cast<QGlyphRun*>(ptr)->setPositions(*static_cast<QVector<QPointF>*>(positions));
}

void QGlyphRun_SetRawData(void* ptr, unsigned int glyphIndexArray, void* glyphPositionArray, int size)
{
	static_cast<QGlyphRun*>(ptr)->setRawData(const_cast<const quint32*>(&glyphIndexArray), static_cast<QPointF*>(glyphPositionArray), size);
}

void QGlyphRun_SetRawFont(void* ptr, void* rawFont)
{
	static_cast<QGlyphRun*>(ptr)->setRawFont(*static_cast<QRawFont*>(rawFont));
}

void QGlyphRun_SetRightToLeft(void* ptr, char rightToLeft)
{
	static_cast<QGlyphRun*>(ptr)->setRightToLeft(rightToLeft != 0);
}

void QGlyphRun_SetStrikeOut(void* ptr, char strikeOut)
{
	static_cast<QGlyphRun*>(ptr)->setStrikeOut(strikeOut != 0);
}

void QGlyphRun_SetUnderline(void* ptr, char underline)
{
	static_cast<QGlyphRun*>(ptr)->setUnderline(underline != 0);
}

void QGlyphRun_Swap(void* ptr, void* other)
{
	static_cast<QGlyphRun*>(ptr)->swap(*static_cast<QGlyphRun*>(other));
}

void QGlyphRun_DestroyQGlyphRun(void* ptr)
{
	static_cast<QGlyphRun*>(ptr)->~QGlyphRun();
}

long long QGlyphRun_Flags(void* ptr)
{
	return static_cast<QGlyphRun*>(ptr)->flags();
}

void* QGlyphRun_RawFont(void* ptr)
{
	return new QRawFont(static_cast<QGlyphRun*>(ptr)->rawFont());
}

void* QGlyphRun_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QGlyphRun*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedList QGlyphRun_Positions(void* ptr)
{
	return ({ QVector<QPointF>* tmpValue = new QVector<QPointF>(static_cast<QGlyphRun*>(ptr)->positions()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QGlyphRun_GlyphIndexes(void* ptr)
{
	return ({ QVector<quint32>* tmpValue = new QVector<quint32>(static_cast<QGlyphRun*>(ptr)->glyphIndexes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

char QGlyphRun_IsEmpty(void* ptr)
{
	return static_cast<QGlyphRun*>(ptr)->isEmpty();
}

char QGlyphRun_IsRightToLeft(void* ptr)
{
	return static_cast<QGlyphRun*>(ptr)->isRightToLeft();
}

char QGlyphRun_Overline(void* ptr)
{
	return static_cast<QGlyphRun*>(ptr)->overline();
}

char QGlyphRun_StrikeOut(void* ptr)
{
	return static_cast<QGlyphRun*>(ptr)->strikeOut();
}

char QGlyphRun_Underline(void* ptr)
{
	return static_cast<QGlyphRun*>(ptr)->underline();
}

unsigned int QGlyphRun___setGlyphIndexes_glyphIndexes_atList(void* ptr, int i)
{
	return static_cast<QVector<quint32>*>(ptr)->at(i);
}

void QGlyphRun___setGlyphIndexes_glyphIndexes_setList(void* ptr, unsigned int i)
{
	static_cast<QVector<quint32>*>(ptr)->append(i);
}

void* QGlyphRun___setGlyphIndexes_glyphIndexes_newList(void* ptr)
{
	return new QVector<quint32>;
}

void* QGlyphRun___setPositions_positions_atList(void* ptr, int i)
{
	return ({ QPointF tmpValue = static_cast<QVector<QPointF>*>(ptr)->at(i); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QGlyphRun___setPositions_positions_setList(void* ptr, void* i)
{
	static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}

void* QGlyphRun___setPositions_positions_newList(void* ptr)
{
	return new QVector<QPointF>;
}

void* QGlyphRun___positions_atList(void* ptr, int i)
{
	return ({ QPointF tmpValue = static_cast<QVector<QPointF>*>(ptr)->at(i); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QGlyphRun___positions_setList(void* ptr, void* i)
{
	static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}

void* QGlyphRun___positions_newList(void* ptr)
{
	return new QVector<QPointF>;
}

unsigned int QGlyphRun___glyphIndexes_atList(void* ptr, int i)
{
	return static_cast<QVector<quint32>*>(ptr)->at(i);
}

void QGlyphRun___glyphIndexes_setList(void* ptr, unsigned int i)
{
	static_cast<QVector<quint32>*>(ptr)->append(i);
}

void* QGlyphRun___glyphIndexes_newList(void* ptr)
{
	return new QVector<quint32>;
}

void QGradient_SetColorAt(void* ptr, double position, void* color)
{
	static_cast<QGradient*>(ptr)->setColorAt(position, *static_cast<QColor*>(color));
}

void QGradient_SetCoordinateMode(void* ptr, long long mode)
{
	static_cast<QGradient*>(ptr)->setCoordinateMode(static_cast<QGradient::CoordinateMode>(mode));
}

void QGradient_SetSpread(void* ptr, long long method)
{
	static_cast<QGradient*>(ptr)->setSpread(static_cast<QGradient::Spread>(method));
}

long long QGradient_CoordinateMode(void* ptr)
{
	return static_cast<QGradient*>(ptr)->coordinateMode();
}

long long QGradient_Spread(void* ptr)
{
	return static_cast<QGradient*>(ptr)->spread();
}

long long QGradient_Type(void* ptr)
{
	return static_cast<QGradient*>(ptr)->type();
}

class MyQGuiApplication: public QGuiApplication
{
public:
	MyQGuiApplication(int &argc, char **argv) : QGuiApplication(argc, argv) {};
	bool event(QEvent * e) { return callbackQGuiApplication_Event(this, e) != 0; };
	void Signal_ApplicationDisplayNameChanged() { callbackQGuiApplication_ApplicationDisplayNameChanged(this); };
	void Signal_ApplicationStateChanged(Qt::ApplicationState state) { callbackQGuiApplication_ApplicationStateChanged(this, state); };
	void Signal_CommitDataRequest(QSessionManager & manager) { callbackQGuiApplication_CommitDataRequest(this, static_cast<QSessionManager*>(&manager)); };
	void Signal_FocusObjectChanged(QObject * focusObject) { callbackQGuiApplication_FocusObjectChanged(this, focusObject); };
	void Signal_FocusWindowChanged(QWindow * focusWindow) { callbackQGuiApplication_FocusWindowChanged(this, focusWindow); };
	void Signal_FontDatabaseChanged() { callbackQGuiApplication_FontDatabaseChanged(this); };
	void Signal_LastWindowClosed() { callbackQGuiApplication_LastWindowClosed(this); };
	void Signal_LayoutDirectionChanged(Qt::LayoutDirection direction) { callbackQGuiApplication_LayoutDirectionChanged(this, direction); };
	void Signal_PaletteChanged(const QPalette & palette) { callbackQGuiApplication_PaletteChanged(this, const_cast<QPalette*>(&palette)); };
	void Signal_PrimaryScreenChanged(QScreen * screen) { callbackQGuiApplication_PrimaryScreenChanged(this, screen); };
	void Signal_SaveStateRequest(QSessionManager & manager) { callbackQGuiApplication_SaveStateRequest(this, static_cast<QSessionManager*>(&manager)); };
	void Signal_ScreenAdded(QScreen * screen) { callbackQGuiApplication_ScreenAdded(this, screen); };
	void Signal_ScreenRemoved(QScreen * screen) { callbackQGuiApplication_ScreenRemoved(this, screen); };
	 ~MyQGuiApplication() { callbackQGuiApplication_DestroyQGuiApplication(this); };
	void Signal_AboutToQuit() { callbackQGuiApplication_AboutToQuit(this); };
	void quit() { callbackQGuiApplication_Quit(this); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQGuiApplication_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQGuiApplication_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQGuiApplication_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQGuiApplication_CustomEvent(this, event); };
	void deleteLater() { callbackQGuiApplication_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQGuiApplication_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQGuiApplication_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQGuiApplication_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQGuiApplication_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGuiApplication_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QGuiApplication_QGuiApplication_Clipboard()
{
	return QGuiApplication::clipboard();
}

void* QGuiApplication_QGuiApplication_OverrideCursor()
{
	return QGuiApplication::overrideCursor();
}

void* QGuiApplication_QGuiApplication_Font()
{
	return new QFont(QGuiApplication::font());
}

void* QGuiApplication_NewQGuiApplication(int argc, char* argv)
{
	static int argcs = argc;
	static char** argvs = static_cast<char**>(malloc(argcs * sizeof(char*)));

	QList<QByteArray> aList = QByteArray(argv).split('|');
	for (int i = 0; i < argcs; i++)
		argvs[i] = (new QByteArray(aList.at(i)))->data();

	return new MyQGuiApplication(argcs, argvs);
}

void* QGuiApplication_QGuiApplication_WindowIcon()
{
	return new QIcon(QGuiApplication::windowIcon());
}

void* QGuiApplication_QGuiApplication_InputMethod()
{
	return QGuiApplication::inputMethod();
}

struct QtGui_PackedList QGuiApplication_QGuiApplication_Screens()
{
	return ({ QList<QScreen *>* tmpValue = new QList<QScreen *>(QGuiApplication::screens()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QGuiApplication_QGuiApplication_FocusObject()
{
	return QGuiApplication::focusObject();
}

void* QGuiApplication_QGuiApplication_Palette()
{
	return new QPalette(QGuiApplication::palette());
}

void* QGuiApplication_QGuiApplication_PrimaryScreen()
{
	return QGuiApplication::primaryScreen();
}

struct QtGui_PackedString QGuiApplication_QGuiApplication_ApplicationDisplayName()
{
	return ({ QByteArray tb2b492 = QGuiApplication::applicationDisplayName().toUtf8(); QtGui_PackedString { const_cast<char*>(tb2b492.prepend("WHITESPACE").constData()+10), tb2b492.size()-10 }; });
}

struct QtGui_PackedString QGuiApplication_QGuiApplication_DesktopFileName()
{
	return ({ QByteArray t174649 = QGuiApplication::desktopFileName().toUtf8(); QtGui_PackedString { const_cast<char*>(t174649.prepend("WHITESPACE").constData()+10), t174649.size()-10 }; });
}

struct QtGui_PackedString QGuiApplication_QGuiApplication_PlatformName()
{
	return ({ QByteArray t498934 = QGuiApplication::platformName().toUtf8(); QtGui_PackedString { const_cast<char*>(t498934.prepend("WHITESPACE").constData()+10), t498934.size()-10 }; });
}

void* QGuiApplication_QGuiApplication_StyleHints()
{
	return QGuiApplication::styleHints();
}

void* QGuiApplication_QGuiApplication_FocusWindow()
{
	return QGuiApplication::focusWindow();
}

void* QGuiApplication_QGuiApplication_ModalWindow()
{
	return QGuiApplication::modalWindow();
}

void* QGuiApplication_QGuiApplication_TopLevelAt(void* pos)
{
	return QGuiApplication::topLevelAt(*static_cast<QPoint*>(pos));
}

long long QGuiApplication_QGuiApplication_ApplicationState()
{
	return QGuiApplication::applicationState();
}

long long QGuiApplication_QGuiApplication_KeyboardModifiers()
{
	return QGuiApplication::keyboardModifiers();
}

long long QGuiApplication_QGuiApplication_QueryKeyboardModifiers()
{
	return QGuiApplication::queryKeyboardModifiers();
}

long long QGuiApplication_QGuiApplication_LayoutDirection()
{
	return QGuiApplication::layoutDirection();
}

long long QGuiApplication_QGuiApplication_MouseButtons()
{
	return QGuiApplication::mouseButtons();
}

char QGuiApplication_QGuiApplication_DesktopSettingsAware()
{
	return QGuiApplication::desktopSettingsAware();
}

char QGuiApplication_EventDefault(void* ptr, void* e)
{
		return static_cast<QGuiApplication*>(ptr)->QGuiApplication::event(static_cast<QEvent*>(e));
}

char QGuiApplication_QGuiApplication_IsFallbackSessionManagementEnabled()
{
	return QGuiApplication::isFallbackSessionManagementEnabled();
}

char QGuiApplication_QGuiApplication_IsLeftToRight()
{
	return QGuiApplication::isLeftToRight();
}

char QGuiApplication_QGuiApplication_IsRightToLeft()
{
	return QGuiApplication::isRightToLeft();
}

char QGuiApplication_QGuiApplication_QuitOnLastWindowClosed()
{
	return QGuiApplication::quitOnLastWindowClosed();
}

int QGuiApplication_QGuiApplication_Exec()
{
	return QGuiApplication::exec();
}

void QGuiApplication_ConnectApplicationDisplayNameChanged(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::applicationDisplayNameChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_ApplicationDisplayNameChanged));
}

void QGuiApplication_DisconnectApplicationDisplayNameChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::applicationDisplayNameChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_ApplicationDisplayNameChanged));
}

void QGuiApplication_ApplicationDisplayNameChanged(void* ptr)
{
	static_cast<QGuiApplication*>(ptr)->applicationDisplayNameChanged();
}

void QGuiApplication_ConnectApplicationStateChanged(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(Qt::ApplicationState)>(&QGuiApplication::applicationStateChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(Qt::ApplicationState)>(&MyQGuiApplication::Signal_ApplicationStateChanged));
}

void QGuiApplication_DisconnectApplicationStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(Qt::ApplicationState)>(&QGuiApplication::applicationStateChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(Qt::ApplicationState)>(&MyQGuiApplication::Signal_ApplicationStateChanged));
}

void QGuiApplication_ApplicationStateChanged(void* ptr, long long state)
{
	static_cast<QGuiApplication*>(ptr)->applicationStateChanged(static_cast<Qt::ApplicationState>(state));
}

void QGuiApplication_QGuiApplication_ChangeOverrideCursor(void* cursor)
{
	QGuiApplication::changeOverrideCursor(*static_cast<QCursor*>(cursor));
}

void QGuiApplication_ConnectCommitDataRequest(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QSessionManager &)>(&QGuiApplication::commitDataRequest), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QSessionManager &)>(&MyQGuiApplication::Signal_CommitDataRequest));
}

void QGuiApplication_DisconnectCommitDataRequest(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QSessionManager &)>(&QGuiApplication::commitDataRequest), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QSessionManager &)>(&MyQGuiApplication::Signal_CommitDataRequest));
}

void QGuiApplication_CommitDataRequest(void* ptr, void* manager)
{
	static_cast<QGuiApplication*>(ptr)->commitDataRequest(*static_cast<QSessionManager*>(manager));
}

void QGuiApplication_ConnectFocusObjectChanged(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QObject *)>(&QGuiApplication::focusObjectChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QObject *)>(&MyQGuiApplication::Signal_FocusObjectChanged));
}

void QGuiApplication_DisconnectFocusObjectChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QObject *)>(&QGuiApplication::focusObjectChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QObject *)>(&MyQGuiApplication::Signal_FocusObjectChanged));
}

void QGuiApplication_FocusObjectChanged(void* ptr, void* focusObject)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(focusObject))) {
		static_cast<QGuiApplication*>(ptr)->focusObjectChanged(static_cast<QOffscreenSurface*>(focusObject));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(focusObject))) {
		static_cast<QGuiApplication*>(ptr)->focusObjectChanged(static_cast<QPaintDeviceWindow*>(focusObject));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(focusObject))) {
		static_cast<QGuiApplication*>(ptr)->focusObjectChanged(static_cast<QPdfWriter*>(focusObject));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(focusObject))) {
		static_cast<QGuiApplication*>(ptr)->focusObjectChanged(static_cast<QWindow*>(focusObject));
	} else {
		static_cast<QGuiApplication*>(ptr)->focusObjectChanged(static_cast<QObject*>(focusObject));
	}
}

void QGuiApplication_ConnectFocusWindowChanged(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QWindow *)>(&QGuiApplication::focusWindowChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QWindow *)>(&MyQGuiApplication::Signal_FocusWindowChanged));
}

void QGuiApplication_DisconnectFocusWindowChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QWindow *)>(&QGuiApplication::focusWindowChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QWindow *)>(&MyQGuiApplication::Signal_FocusWindowChanged));
}

void QGuiApplication_FocusWindowChanged(void* ptr, void* focusWindow)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(focusWindow))) {
		static_cast<QGuiApplication*>(ptr)->focusWindowChanged(static_cast<QPaintDeviceWindow*>(focusWindow));
	} else {
		static_cast<QGuiApplication*>(ptr)->focusWindowChanged(static_cast<QWindow*>(focusWindow));
	}
}

void QGuiApplication_ConnectFontDatabaseChanged(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::fontDatabaseChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_FontDatabaseChanged));
}

void QGuiApplication_DisconnectFontDatabaseChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::fontDatabaseChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_FontDatabaseChanged));
}

void QGuiApplication_FontDatabaseChanged(void* ptr)
{
	static_cast<QGuiApplication*>(ptr)->fontDatabaseChanged();
}

void QGuiApplication_ConnectLastWindowClosed(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::lastWindowClosed), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_LastWindowClosed));
}

void QGuiApplication_DisconnectLastWindowClosed(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)()>(&QGuiApplication::lastWindowClosed), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)()>(&MyQGuiApplication::Signal_LastWindowClosed));
}

void QGuiApplication_LastWindowClosed(void* ptr)
{
	static_cast<QGuiApplication*>(ptr)->lastWindowClosed();
}

void QGuiApplication_ConnectLayoutDirectionChanged(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(Qt::LayoutDirection)>(&QGuiApplication::layoutDirectionChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(Qt::LayoutDirection)>(&MyQGuiApplication::Signal_LayoutDirectionChanged));
}

void QGuiApplication_DisconnectLayoutDirectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(Qt::LayoutDirection)>(&QGuiApplication::layoutDirectionChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(Qt::LayoutDirection)>(&MyQGuiApplication::Signal_LayoutDirectionChanged));
}

void QGuiApplication_LayoutDirectionChanged(void* ptr, long long direction)
{
	static_cast<QGuiApplication*>(ptr)->layoutDirectionChanged(static_cast<Qt::LayoutDirection>(direction));
}

void QGuiApplication_ConnectPaletteChanged(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(const QPalette &)>(&QGuiApplication::paletteChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(const QPalette &)>(&MyQGuiApplication::Signal_PaletteChanged));
}

void QGuiApplication_DisconnectPaletteChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(const QPalette &)>(&QGuiApplication::paletteChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(const QPalette &)>(&MyQGuiApplication::Signal_PaletteChanged));
}

void QGuiApplication_PaletteChanged(void* ptr, void* palette)
{
	static_cast<QGuiApplication*>(ptr)->paletteChanged(*static_cast<QPalette*>(palette));
}

void QGuiApplication_ConnectPrimaryScreenChanged(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::primaryScreenChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_PrimaryScreenChanged));
}

void QGuiApplication_DisconnectPrimaryScreenChanged(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::primaryScreenChanged), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_PrimaryScreenChanged));
}

void QGuiApplication_PrimaryScreenChanged(void* ptr, void* screen)
{
	static_cast<QGuiApplication*>(ptr)->primaryScreenChanged(static_cast<QScreen*>(screen));
}

void QGuiApplication_QGuiApplication_RestoreOverrideCursor()
{
	QGuiApplication::restoreOverrideCursor();
}

void QGuiApplication_ConnectSaveStateRequest(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QSessionManager &)>(&QGuiApplication::saveStateRequest), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QSessionManager &)>(&MyQGuiApplication::Signal_SaveStateRequest));
}

void QGuiApplication_DisconnectSaveStateRequest(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QSessionManager &)>(&QGuiApplication::saveStateRequest), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QSessionManager &)>(&MyQGuiApplication::Signal_SaveStateRequest));
}

void QGuiApplication_SaveStateRequest(void* ptr, void* manager)
{
	static_cast<QGuiApplication*>(ptr)->saveStateRequest(*static_cast<QSessionManager*>(manager));
}

void QGuiApplication_ConnectScreenAdded(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::screenAdded), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_ScreenAdded));
}

void QGuiApplication_DisconnectScreenAdded(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::screenAdded), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_ScreenAdded));
}

void QGuiApplication_ScreenAdded(void* ptr, void* screen)
{
	static_cast<QGuiApplication*>(ptr)->screenAdded(static_cast<QScreen*>(screen));
}

void QGuiApplication_ConnectScreenRemoved(void* ptr)
{
	QObject::connect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::screenRemoved), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_ScreenRemoved));
}

void QGuiApplication_DisconnectScreenRemoved(void* ptr)
{
	QObject::disconnect(static_cast<QGuiApplication*>(ptr), static_cast<void (QGuiApplication::*)(QScreen *)>(&QGuiApplication::screenRemoved), static_cast<MyQGuiApplication*>(ptr), static_cast<void (MyQGuiApplication::*)(QScreen *)>(&MyQGuiApplication::Signal_ScreenRemoved));
}

void QGuiApplication_ScreenRemoved(void* ptr, void* screen)
{
	static_cast<QGuiApplication*>(ptr)->screenRemoved(static_cast<QScreen*>(screen));
}

void QGuiApplication_QGuiApplication_SetApplicationDisplayName(char* name)
{
	QGuiApplication::setApplicationDisplayName(QString(name));
}

void QGuiApplication_QGuiApplication_SetDesktopFileName(char* name)
{
	QGuiApplication::setDesktopFileName(QString(name));
}

void QGuiApplication_QGuiApplication_SetDesktopSettingsAware(char on)
{
	QGuiApplication::setDesktopSettingsAware(on != 0);
}

void QGuiApplication_QGuiApplication_SetFallbackSessionManagementEnabled(char enabled)
{
	QGuiApplication::setFallbackSessionManagementEnabled(enabled != 0);
}

void QGuiApplication_QGuiApplication_SetFont(void* font)
{
	QGuiApplication::setFont(*static_cast<QFont*>(font));
}

void QGuiApplication_QGuiApplication_SetLayoutDirection(long long direction)
{
	QGuiApplication::setLayoutDirection(static_cast<Qt::LayoutDirection>(direction));
}

void QGuiApplication_QGuiApplication_SetOverrideCursor(void* cursor)
{
	QGuiApplication::setOverrideCursor(*static_cast<QCursor*>(cursor));
}

void QGuiApplication_QGuiApplication_SetPalette(void* pal)
{
	QGuiApplication::setPalette(*static_cast<QPalette*>(pal));
}

void QGuiApplication_QGuiApplication_SetQuitOnLastWindowClosed(char quit)
{
	QGuiApplication::setQuitOnLastWindowClosed(quit != 0);
}

void QGuiApplication_QGuiApplication_SetWindowIcon(void* icon)
{
	QGuiApplication::setWindowIcon(*static_cast<QIcon*>(icon));
}

void QGuiApplication_QGuiApplication_Sync()
{
	QGuiApplication::sync();
}

void QGuiApplication_DestroyQGuiApplication(void* ptr)
{
	static_cast<QGuiApplication*>(ptr)->~QGuiApplication();
}

void QGuiApplication_DestroyQGuiApplicationDefault(void* ptr)
{

}

struct QtGui_PackedString QGuiApplication_SessionId(void* ptr)
{
	return ({ QByteArray td2baef = static_cast<QGuiApplication*>(ptr)->sessionId().toUtf8(); QtGui_PackedString { const_cast<char*>(td2baef.prepend("WHITESPACE").constData()+10), td2baef.size()-10 }; });
}

struct QtGui_PackedString QGuiApplication_SessionKey(void* ptr)
{
	return ({ QByteArray t076332 = static_cast<QGuiApplication*>(ptr)->sessionKey().toUtf8(); QtGui_PackedString { const_cast<char*>(t076332.prepend("WHITESPACE").constData()+10), t076332.size()-10 }; });
}

char QGuiApplication_IsSavingSession(void* ptr)
{
	return static_cast<QGuiApplication*>(ptr)->isSavingSession();
}

char QGuiApplication_IsSessionRestored(void* ptr)
{
	return static_cast<QGuiApplication*>(ptr)->isSessionRestored();
}

double QGuiApplication_DevicePixelRatio(void* ptr)
{
	return static_cast<QGuiApplication*>(ptr)->devicePixelRatio();
}

void* QGuiApplication___screens_atList(void* ptr, int i)
{
	return const_cast<QScreen*>(static_cast<QList<QScreen *>*>(ptr)->at(i));
}

void QGuiApplication___screens_setList(void* ptr, void* i)
{
	static_cast<QList<QScreen *>*>(ptr)->append(static_cast<QScreen*>(i));
}

void* QGuiApplication___screens_newList(void* ptr)
{
	return new QList<QScreen *>;
}

void* QGuiApplication___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QGuiApplication___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QGuiApplication___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QGuiApplication___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QGuiApplication___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QGuiApplication___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QGuiApplication___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QGuiApplication___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QGuiApplication___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QGuiApplication___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QGuiApplication___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QGuiApplication___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QGuiApplication___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QGuiApplication___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QGuiApplication___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

void QGuiApplication_QuitDefault(void* ptr)
{
		static_cast<QGuiApplication*>(ptr)->QGuiApplication::quit();
}

char QGuiApplication_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QGuiApplication*>(ptr)->QGuiApplication::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QGuiApplication*>(ptr)->QGuiApplication::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QGuiApplication*>(ptr)->QGuiApplication::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QGuiApplication*>(ptr)->QGuiApplication::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QGuiApplication*>(ptr)->QGuiApplication::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QGuiApplication_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QGuiApplication*>(ptr)->QGuiApplication::childEvent(static_cast<QChildEvent*>(event));
}

void QGuiApplication_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QGuiApplication*>(ptr)->QGuiApplication::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QGuiApplication_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QGuiApplication*>(ptr)->QGuiApplication::customEvent(static_cast<QEvent*>(event));
}

void QGuiApplication_DeleteLaterDefault(void* ptr)
{
		static_cast<QGuiApplication*>(ptr)->QGuiApplication::deleteLater();
}

void QGuiApplication_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QGuiApplication*>(ptr)->QGuiApplication::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QGuiApplication_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QGuiApplication*>(ptr)->QGuiApplication::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QGuiApplication_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QGuiApplication*>(ptr)->QGuiApplication::metaObject());
}

class MyQHelpEvent: public QHelpEvent
{
public:
	MyQHelpEvent(Type type, const QPoint &pos, const QPoint &globalPos) : QHelpEvent(type, pos, globalPos) {};
};

void* QHelpEvent_NewQHelpEvent(long long ty, void* pos, void* globalPos)
{
	return new MyQHelpEvent(static_cast<QEvent::Type>(ty), *static_cast<QPoint*>(pos), *static_cast<QPoint*>(globalPos));
}

void* QHelpEvent_GlobalPos(void* ptr)
{
	return const_cast<QPoint*>(&static_cast<QHelpEvent*>(ptr)->globalPos());
}

void* QHelpEvent_Pos(void* ptr)
{
	return const_cast<QPoint*>(&static_cast<QHelpEvent*>(ptr)->pos());
}

int QHelpEvent_GlobalX(void* ptr)
{
	return static_cast<QHelpEvent*>(ptr)->globalX();
}

int QHelpEvent_GlobalY(void* ptr)
{
	return static_cast<QHelpEvent*>(ptr)->globalY();
}

int QHelpEvent_X(void* ptr)
{
	return static_cast<QHelpEvent*>(ptr)->x();
}

int QHelpEvent_Y(void* ptr)
{
	return static_cast<QHelpEvent*>(ptr)->y();
}

class MyQHideEvent: public QHideEvent
{
public:
	MyQHideEvent() : QHideEvent() {};
};

void* QHideEvent_NewQHideEvent()
{
	return new MyQHideEvent();
}

class MyQHoverEvent: public QHoverEvent
{
public:
	MyQHoverEvent(Type type, const QPointF &pos, const QPointF &oldPos, Qt::KeyboardModifiers modifiers) : QHoverEvent(type, pos, oldPos, modifiers) {};
};

void* QHoverEvent_NewQHoverEvent(long long ty, void* pos, void* oldPos, long long modifiers)
{
	return new MyQHoverEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(pos), *static_cast<QPointF*>(oldPos), static_cast<Qt::KeyboardModifier>(modifiers));
}

void* QHoverEvent_OldPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QHoverEvent*>(ptr)->oldPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QHoverEvent_Pos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QHoverEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QHoverEvent_OldPosF(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QHoverEvent*>(ptr)->oldPosF());
}

void* QHoverEvent_PosF(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QHoverEvent*>(ptr)->posF());
}

void* QIcon_QIcon_FromTheme(char* name)
{
	return new QIcon(QIcon::fromTheme(QString(name)));
}

void* QIcon_QIcon_FromTheme2(char* name, void* fallback)
{
	return new QIcon(QIcon::fromTheme(QString(name), *static_cast<QIcon*>(fallback)));
}

void* QIcon_NewQIcon()
{
	return new QIcon();
}

void* QIcon_NewQIcon4(void* other)
{
	return new QIcon(*static_cast<QIcon*>(other));
}

void* QIcon_NewQIcon6(void* engine)
{
	return new QIcon(static_cast<QIconEngine*>(engine));
}

void* QIcon_NewQIcon3(void* other)
{
	return new QIcon(*static_cast<QIcon*>(other));
}

void* QIcon_NewQIcon2(void* pixmap)
{
	return new QIcon(*static_cast<QPixmap*>(pixmap));
}

void* QIcon_NewQIcon5(char* fileName)
{
	return new QIcon(QString(fileName));
}

struct QtGui_PackedString QIcon_QIcon_ThemeName()
{
	return ({ QByteArray tf4fe63 = QIcon::themeName().toUtf8(); QtGui_PackedString { const_cast<char*>(tf4fe63.prepend("WHITESPACE").constData()+10), tf4fe63.size()-10 }; });
}

struct QtGui_PackedString QIcon_QIcon_ThemeSearchPaths()
{
	return ({ QByteArray t9c13b7 = QIcon::themeSearchPaths().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t9c13b7.prepend("WHITESPACE").constData()+10), t9c13b7.size()-10 }; });
}

char QIcon_QIcon_HasThemeIcon(char* name)
{
	return QIcon::hasThemeIcon(QString(name));
}

void QIcon_AddFile(void* ptr, char* fileName, void* size, long long mode, long long state)
{
	static_cast<QIcon*>(ptr)->addFile(QString(fileName), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}

void QIcon_AddPixmap(void* ptr, void* pixmap, long long mode, long long state)
{
	static_cast<QIcon*>(ptr)->addPixmap(*static_cast<QPixmap*>(pixmap), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}

void QIcon_SetIsMask(void* ptr, char isMask)
{
	static_cast<QIcon*>(ptr)->setIsMask(isMask != 0);
}

void QIcon_QIcon_SetThemeName(char* name)
{
	QIcon::setThemeName(QString(name));
}

void QIcon_QIcon_SetThemeSearchPaths(char* paths)
{
	QIcon::setThemeSearchPaths(QString(paths).split("|", QString::SkipEmptyParts));
}

void QIcon_Swap(void* ptr, void* other)
{
	static_cast<QIcon*>(ptr)->swap(*static_cast<QIcon*>(other));
}

void QIcon_DestroyQIcon(void* ptr)
{
	static_cast<QIcon*>(ptr)->~QIcon();
}

struct QtGui_PackedList QIcon_AvailableSizes(void* ptr, long long mode, long long state)
{
	return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QIcon*>(ptr)->availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QIcon_Pixmap4(void* ptr, void* window, void* size, long long mode, long long state)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(window))) {
		return new QPixmap(static_cast<QIcon*>(ptr)->pixmap(static_cast<QPaintDeviceWindow*>(window), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
	} else {
		return new QPixmap(static_cast<QIcon*>(ptr)->pixmap(static_cast<QWindow*>(window), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
	}
}

void* QIcon_Pixmap(void* ptr, void* size, long long mode, long long state)
{
	return new QPixmap(static_cast<QIcon*>(ptr)->pixmap(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}

void* QIcon_Pixmap3(void* ptr, int extent, long long mode, long long state)
{
	return new QPixmap(static_cast<QIcon*>(ptr)->pixmap(extent, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}

void* QIcon_Pixmap2(void* ptr, int w, int h, long long mode, long long state)
{
	return new QPixmap(static_cast<QIcon*>(ptr)->pixmap(w, h, static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}

void* QIcon_ActualSize2(void* ptr, void* window, void* size, long long mode, long long state)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(window))) {
		return ({ QSize tmpValue = static_cast<QIcon*>(ptr)->actualSize(static_cast<QPaintDeviceWindow*>(window), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QIcon*>(ptr)->actualSize(static_cast<QWindow*>(window), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QIcon_ActualSize(void* ptr, void* size, long long mode, long long state)
{
	return ({ QSize tmpValue = static_cast<QIcon*>(ptr)->actualSize(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)); new QSize(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QIcon_Name(void* ptr)
{
	return ({ QByteArray t03700a = static_cast<QIcon*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(t03700a.prepend("WHITESPACE").constData()+10), t03700a.size()-10 }; });
}

char QIcon_IsMask(void* ptr)
{
	return static_cast<QIcon*>(ptr)->isMask();
}

char QIcon_IsNull(void* ptr)
{
	return static_cast<QIcon*>(ptr)->isNull();
}

long long QIcon_CacheKey(void* ptr)
{
	return static_cast<QIcon*>(ptr)->cacheKey();
}

void QIcon_Paint(void* ptr, void* painter, void* rect, long long alignment, long long mode, long long state)
{
	static_cast<QIcon*>(ptr)->paint(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), static_cast<Qt::AlignmentFlag>(alignment), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}

void QIcon_Paint2(void* ptr, void* painter, int x, int y, int w, int h, long long alignment, long long mode, long long state)
{
	static_cast<QIcon*>(ptr)->paint(static_cast<QPainter*>(painter), x, y, w, h, static_cast<Qt::AlignmentFlag>(alignment), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}

void* QIcon___availableSizes_atList(void* ptr, int i)
{
	return ({ QSize tmpValue = static_cast<QList<QSize>*>(ptr)->at(i); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QIcon___availableSizes_setList(void* ptr, void* i)
{
	static_cast<QList<QSize>*>(ptr)->append(*static_cast<QSize*>(i));
}

void* QIcon___availableSizes_newList(void* ptr)
{
	return new QList<QSize>;
}

class MyQIconDragEvent: public QIconDragEvent
{
public:
	MyQIconDragEvent() : QIconDragEvent() {};
};

void* QIconDragEvent_NewQIconDragEvent()
{
	return new MyQIconDragEvent();
}

class MyQIconEngine: public QIconEngine
{
public:
	MyQIconEngine() : QIconEngine() {};
	QPixmap pixmap(const QSize & size, QIcon::Mode mode, QIcon::State state) { return *static_cast<QPixmap*>(callbackQIconEngine_Pixmap(this, const_cast<QSize*>(&size), mode, state)); };
	QSize actualSize(const QSize & size, QIcon::Mode mode, QIcon::State state) { return *static_cast<QSize*>(callbackQIconEngine_ActualSize(this, const_cast<QSize*>(&size), mode, state)); };
	bool read(QDataStream & in) { return callbackQIconEngine_Read(this, static_cast<QDataStream*>(&in)) != 0; };
	void addFile(const QString & fileName, const QSize & size, QIcon::Mode mode, QIcon::State state) { QByteArray td83e09 = fileName.toUtf8(); QtGui_PackedString fileNamePacked = { const_cast<char*>(td83e09.prepend("WHITESPACE").constData()+10), td83e09.size()-10 };callbackQIconEngine_AddFile(this, fileNamePacked, const_cast<QSize*>(&size), mode, state); };
	void addPixmap(const QPixmap & pixmap, QIcon::Mode mode, QIcon::State state) { callbackQIconEngine_AddPixmap(this, const_cast<QPixmap*>(&pixmap), mode, state); };
	void paint(QPainter * painter, const QRect & rect, QIcon::Mode mode, QIcon::State state) { callbackQIconEngine_Paint(this, painter, const_cast<QRect*>(&rect), mode, state); };
	void virtual_hook(int id, void * data) { callbackQIconEngine_Virtual_hook(this, id, data); };
	 ~MyQIconEngine() { callbackQIconEngine_DestroyQIconEngine(this); };
	QIconEngine * clone() const { return static_cast<QIconEngine*>(callbackQIconEngine_Clone(const_cast<void*>(static_cast<const void*>(this)))); };
	QList<QSize> availableSizes(QIcon::Mode mode, QIcon::State state) const { return *static_cast<QList<QSize>*>(callbackQIconEngine_AvailableSizes(const_cast<void*>(static_cast<const void*>(this)), mode, state)); };
	QString iconName() const { return QString(callbackQIconEngine_IconName(const_cast<void*>(static_cast<const void*>(this)))); };
	QString key() const { return QString(callbackQIconEngine_Key(const_cast<void*>(static_cast<const void*>(this)))); };
	bool write(QDataStream & out) const { return callbackQIconEngine_Write(const_cast<void*>(static_cast<const void*>(this)), static_cast<QDataStream*>(&out)) != 0; };
};

void* QIconEngine_NewQIconEngine()
{
	return new MyQIconEngine();
}

void* QIconEngine_Pixmap(void* ptr, void* size, long long mode, long long state)
{
	return new QPixmap(static_cast<QIconEngine*>(ptr)->pixmap(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}

void* QIconEngine_PixmapDefault(void* ptr, void* size, long long mode, long long state)
{
		return new QPixmap(static_cast<QIconEngine*>(ptr)->QIconEngine::pixmap(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)));
}

void* QIconEngine_ActualSize(void* ptr, void* size, long long mode, long long state)
{
	return ({ QSize tmpValue = static_cast<QIconEngine*>(ptr)->actualSize(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QIconEngine_ActualSizeDefault(void* ptr, void* size, long long mode, long long state)
{
		return ({ QSize tmpValue = static_cast<QIconEngine*>(ptr)->QIconEngine::actualSize(*static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state)); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QIconEngine_Read(void* ptr, void* in)
{
	return static_cast<QIconEngine*>(ptr)->read(*static_cast<QDataStream*>(in));
}

char QIconEngine_ReadDefault(void* ptr, void* in)
{
		return static_cast<QIconEngine*>(ptr)->QIconEngine::read(*static_cast<QDataStream*>(in));
}

void QIconEngine_AddFile(void* ptr, char* fileName, void* size, long long mode, long long state)
{
	static_cast<QIconEngine*>(ptr)->addFile(QString(fileName), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}

void QIconEngine_AddFileDefault(void* ptr, char* fileName, void* size, long long mode, long long state)
{
		static_cast<QIconEngine*>(ptr)->QIconEngine::addFile(QString(fileName), *static_cast<QSize*>(size), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}

void QIconEngine_AddPixmap(void* ptr, void* pixmap, long long mode, long long state)
{
	static_cast<QIconEngine*>(ptr)->addPixmap(*static_cast<QPixmap*>(pixmap), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}

void QIconEngine_AddPixmapDefault(void* ptr, void* pixmap, long long mode, long long state)
{
		static_cast<QIconEngine*>(ptr)->QIconEngine::addPixmap(*static_cast<QPixmap*>(pixmap), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}

void QIconEngine_Paint(void* ptr, void* painter, void* rect, long long mode, long long state)
{
	static_cast<QIconEngine*>(ptr)->paint(static_cast<QPainter*>(painter), *static_cast<QRect*>(rect), static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state));
}

void QIconEngine_Virtual_hook(void* ptr, int id, void* data)
{
	static_cast<QIconEngine*>(ptr)->virtual_hook(id, data);
}

void QIconEngine_Virtual_hookDefault(void* ptr, int id, void* data)
{
		static_cast<QIconEngine*>(ptr)->QIconEngine::virtual_hook(id, data);
}

void QIconEngine_DestroyQIconEngine(void* ptr)
{
	static_cast<QIconEngine*>(ptr)->~QIconEngine();
}

void QIconEngine_DestroyQIconEngineDefault(void* ptr)
{

}

void* QIconEngine_Clone(void* ptr)
{
	return static_cast<QIconEngine*>(ptr)->clone();
}

struct QtGui_PackedList QIconEngine_AvailableSizes(void* ptr, long long mode, long long state)
{
	return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QIconEngine*>(ptr)->availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QIconEngine_AvailableSizesDefault(void* ptr, long long mode, long long state)
{
		return ({ QList<QSize>* tmpValue = new QList<QSize>(static_cast<QIconEngine*>(ptr)->QIconEngine::availableSizes(static_cast<QIcon::Mode>(mode), static_cast<QIcon::State>(state))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedString QIconEngine_IconName(void* ptr)
{
	return ({ QByteArray te81faa = static_cast<QIconEngine*>(ptr)->iconName().toUtf8(); QtGui_PackedString { const_cast<char*>(te81faa.prepend("WHITESPACE").constData()+10), te81faa.size()-10 }; });
}

struct QtGui_PackedString QIconEngine_IconNameDefault(void* ptr)
{
		return ({ QByteArray t0024e2 = static_cast<QIconEngine*>(ptr)->QIconEngine::iconName().toUtf8(); QtGui_PackedString { const_cast<char*>(t0024e2.prepend("WHITESPACE").constData()+10), t0024e2.size()-10 }; });
}

struct QtGui_PackedString QIconEngine_Key(void* ptr)
{
	return ({ QByteArray tfa2543 = static_cast<QIconEngine*>(ptr)->key().toUtf8(); QtGui_PackedString { const_cast<char*>(tfa2543.prepend("WHITESPACE").constData()+10), tfa2543.size()-10 }; });
}

struct QtGui_PackedString QIconEngine_KeyDefault(void* ptr)
{
		return ({ QByteArray t9979b6 = static_cast<QIconEngine*>(ptr)->QIconEngine::key().toUtf8(); QtGui_PackedString { const_cast<char*>(t9979b6.prepend("WHITESPACE").constData()+10), t9979b6.size()-10 }; });
}

char QIconEngine_IsNull(void* ptr)
{
	return static_cast<QIconEngine*>(ptr)->isNull();
}

char QIconEngine_Write(void* ptr, void* out)
{
	return static_cast<QIconEngine*>(ptr)->write(*static_cast<QDataStream*>(out));
}

char QIconEngine_WriteDefault(void* ptr, void* out)
{
		return static_cast<QIconEngine*>(ptr)->QIconEngine::write(*static_cast<QDataStream*>(out));
}

void* QIconEngine___availableSizes_atList(void* ptr, int i)
{
	return ({ QSize tmpValue = static_cast<QList<QSize>*>(ptr)->at(i); new QSize(tmpValue.width(), tmpValue.height()); });
}

void QIconEngine___availableSizes_setList(void* ptr, void* i)
{
	static_cast<QList<QSize>*>(ptr)->append(*static_cast<QSize*>(i));
}

void* QIconEngine___availableSizes_newList(void* ptr)
{
	return new QList<QSize>;
}

class MyQIconEnginePlugin: public QIconEnginePlugin
{
public:
	MyQIconEnginePlugin(QObject *parent) : QIconEnginePlugin(parent) {};
	QIconEngine * create(const QString & filename) { QByteArray t08deae = filename.toUtf8(); QtGui_PackedString filenamePacked = { const_cast<char*>(t08deae.prepend("WHITESPACE").constData()+10), t08deae.size()-10 };return static_cast<QIconEngine*>(callbackQIconEnginePlugin_Create(this, filenamePacked)); };
	bool event(QEvent * e) { return callbackQIconEnginePlugin_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQIconEnginePlugin_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQIconEnginePlugin_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQIconEnginePlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQIconEnginePlugin_CustomEvent(this, event); };
	void deleteLater() { callbackQIconEnginePlugin_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQIconEnginePlugin_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQIconEnginePlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQIconEnginePlugin_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQIconEnginePlugin_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQIconEnginePlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QIconEnginePlugin_Create(void* ptr, char* filename)
{
	return static_cast<QIconEnginePlugin*>(ptr)->create(QString(filename));
}

void* QIconEnginePlugin_NewQIconEnginePlugin(void* parent)
{
	return new MyQIconEnginePlugin(static_cast<QObject*>(parent));
}

void QIconEnginePlugin_DestroyQIconEnginePlugin(void* ptr)
{
	static_cast<QIconEnginePlugin*>(ptr)->~QIconEnginePlugin();
}

void* QIconEnginePlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QIconEnginePlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QIconEnginePlugin___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QIconEnginePlugin___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QIconEnginePlugin___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QIconEnginePlugin___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QIconEnginePlugin___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QIconEnginePlugin___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QIconEnginePlugin___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QIconEnginePlugin___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QIconEnginePlugin___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QIconEnginePlugin___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QIconEnginePlugin___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QIconEnginePlugin___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QIconEnginePlugin___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QIconEnginePlugin_EventDefault(void* ptr, void* e)
{
		return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::event(static_cast<QEvent*>(e));
}

char QIconEnginePlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QIconEnginePlugin_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::childEvent(static_cast<QChildEvent*>(event));
}

void QIconEnginePlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QIconEnginePlugin_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::customEvent(static_cast<QEvent*>(event));
}

void QIconEnginePlugin_DeleteLaterDefault(void* ptr)
{
		static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::deleteLater();
}

void QIconEnginePlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QIconEnginePlugin_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QIconEnginePlugin_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QIconEnginePlugin*>(ptr)->QIconEnginePlugin::metaObject());
}

class MyQImage: public QImage
{
public:
	MyQImage() : QImage() {};
	MyQImage(QImage &&other) : QImage(other) {};
	MyQImage(const QImage &image) : QImage(image) {};
	MyQImage(const QSize &size, Format format) : QImage(size, format) {};
	MyQImage(const QString &fileName, const char *format) : QImage(fileName, format) {};
	MyQImage(int width, int height, Format format) : QImage(width, height, format) {};
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQImage_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};

void* QImage_QImage_FromData2(void* data, char* format)
{
	return new QImage(QImage::fromData(*static_cast<QByteArray*>(data), const_cast<const char*>(format)));
}

void* QImage_QImage_FromData(char* data, int size, char* format)
{
	return new QImage(QImage::fromData(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(data))), size, const_cast<const char*>(format)));
}

void* QImage_NewQImage()
{
	return new MyQImage();
}

void* QImage_NewQImage11(void* other)
{
	return new MyQImage(*static_cast<QImage*>(other));
}

void* QImage_NewQImage10(void* image)
{
	return new MyQImage(*static_cast<QImage*>(image));
}

void* QImage_NewQImage2(void* size, long long format)
{
	return new MyQImage(*static_cast<QSize*>(size), static_cast<QImage::Format>(format));
}

void* QImage_NewQImage9(char* fileName, char* format)
{
	return new MyQImage(QString(fileName), const_cast<const char*>(format));
}

void* QImage_NewQImage3(int width, int height, long long format)
{
	return new MyQImage(width, height, static_cast<QImage::Format>(format));
}

long long QImage_QImage_ToImageFormat(void* format)
{
	return QImage::toImageFormat(*static_cast<QPixelFormat*>(format));
}

void* QImage_QImage_ToPixelFormat(long long format)
{
	return new QPixelFormat(QImage::toPixelFormat(static_cast<QImage::Format>(format)));
}

void* QImage_QImage_TrueMatrix2(void* matrix, int width, int height)
{
	return new QTransform(QImage::trueMatrix(*static_cast<QTransform*>(matrix), width, height));
}

char QImage_Load2(void* ptr, void* device, char* format)
{
	return static_cast<QImage*>(ptr)->load(static_cast<QIODevice*>(device), const_cast<const char*>(format));
}

char QImage_Load(void* ptr, char* fileName, char* format)
{
	return static_cast<QImage*>(ptr)->load(QString(fileName), const_cast<const char*>(format));
}

char QImage_LoadFromData2(void* ptr, void* data, char* format)
{
	return static_cast<QImage*>(ptr)->loadFromData(*static_cast<QByteArray*>(data), const_cast<const char*>(format));
}

char QImage_LoadFromData(void* ptr, char* data, int len, char* format)
{
	return static_cast<QImage*>(ptr)->loadFromData(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(data))), len, const_cast<const char*>(format));
}

struct QtGui_PackedString QImage_Bits(void* ptr)
{
	return ({ char* te11021 = static_cast<char*>(static_cast<void*>(static_cast<QImage*>(ptr)->bits())); QtGui_PackedString { te11021, -1 }; });
}

struct QtGui_PackedString QImage_ScanLine(void* ptr, int i)
{
	return ({ char* t3248e5 = static_cast<char*>(static_cast<void*>(static_cast<QImage*>(ptr)->scanLine(i))); QtGui_PackedString { t3248e5, -1 }; });
}

void QImage_Fill3(void* ptr, long long color)
{
	static_cast<QImage*>(ptr)->fill(static_cast<Qt::GlobalColor>(color));
}

void QImage_Fill2(void* ptr, void* color)
{
	static_cast<QImage*>(ptr)->fill(*static_cast<QColor*>(color));
}

void QImage_Fill(void* ptr, unsigned int pixelValue)
{
	static_cast<QImage*>(ptr)->fill(pixelValue);
}

void QImage_InvertPixels(void* ptr, long long mode)
{
	static_cast<QImage*>(ptr)->invertPixels(static_cast<QImage::InvertMode>(mode));
}

void QImage_SetColorCount(void* ptr, int colorCount)
{
	static_cast<QImage*>(ptr)->setColorCount(colorCount);
}

void QImage_SetDevicePixelRatio(void* ptr, double scaleFactor)
{
	static_cast<QImage*>(ptr)->setDevicePixelRatio(scaleFactor);
}

void QImage_SetDotsPerMeterX(void* ptr, int x)
{
	static_cast<QImage*>(ptr)->setDotsPerMeterX(x);
}

void QImage_SetDotsPerMeterY(void* ptr, int y)
{
	static_cast<QImage*>(ptr)->setDotsPerMeterY(y);
}

void QImage_SetOffset(void* ptr, void* offset)
{
	static_cast<QImage*>(ptr)->setOffset(*static_cast<QPoint*>(offset));
}

void QImage_SetPixel(void* ptr, void* position, unsigned int index_or_rgb)
{
	static_cast<QImage*>(ptr)->setPixel(*static_cast<QPoint*>(position), index_or_rgb);
}

void QImage_SetPixel2(void* ptr, int x, int y, unsigned int index_or_rgb)
{
	static_cast<QImage*>(ptr)->setPixel(x, y, index_or_rgb);
}

void QImage_SetPixelColor(void* ptr, void* position, void* color)
{
	static_cast<QImage*>(ptr)->setPixelColor(*static_cast<QPoint*>(position), *static_cast<QColor*>(color));
}

void QImage_SetPixelColor2(void* ptr, int x, int y, void* color)
{
	static_cast<QImage*>(ptr)->setPixelColor(x, y, *static_cast<QColor*>(color));
}

void QImage_SetText(void* ptr, char* key, char* text)
{
	static_cast<QImage*>(ptr)->setText(QString(key), QString(text));
}

void QImage_Swap(void* ptr, void* other)
{
	static_cast<QImage*>(ptr)->swap(*static_cast<QImage*>(other));
}

void QImage_DestroyQImage(void* ptr)
{
	static_cast<QImage*>(ptr)->~QImage();
}

long long QImage_Format(void* ptr)
{
	return static_cast<QImage*>(ptr)->format();
}

void* QImage_PixelColor(void* ptr, void* position)
{
	return new QColor(static_cast<QImage*>(ptr)->pixelColor(*static_cast<QPoint*>(position)));
}

void* QImage_PixelColor2(void* ptr, int x, int y)
{
	return new QColor(static_cast<QImage*>(ptr)->pixelColor(x, y));
}

void* QImage_ConvertToFormat(void* ptr, long long format, long long flags)
{
	return new QImage(static_cast<QImage*>(ptr)->convertToFormat(static_cast<QImage::Format>(format), static_cast<Qt::ImageConversionFlag>(flags)));
}

void* QImage_Copy(void* ptr, void* rectangle)
{
	return new QImage(static_cast<QImage*>(ptr)->copy(*static_cast<QRect*>(rectangle)));
}

void* QImage_Copy2(void* ptr, int x, int y, int width, int height)
{
	return new QImage(static_cast<QImage*>(ptr)->copy(x, y, width, height));
}

void* QImage_CreateAlphaMask(void* ptr, long long flags)
{
	return new QImage(static_cast<QImage*>(ptr)->createAlphaMask(static_cast<Qt::ImageConversionFlag>(flags)));
}

void* QImage_CreateHeuristicMask(void* ptr, char clipTight)
{
	return new QImage(static_cast<QImage*>(ptr)->createHeuristicMask(clipTight != 0));
}

void* QImage_Mirrored(void* ptr, char horizontal, char vertical)
{
	return new QImage(static_cast<QImage*>(ptr)->mirrored(horizontal != 0, vertical != 0));
}

void* QImage_RgbSwapped(void* ptr)
{
	return new QImage(static_cast<QImage*>(ptr)->rgbSwapped());
}

void* QImage_Scaled(void* ptr, void* size, long long aspectRatioMode, long long transformMode)
{
	return new QImage(static_cast<QImage*>(ptr)->scaled(*static_cast<QSize*>(size), static_cast<Qt::AspectRatioMode>(aspectRatioMode), static_cast<Qt::TransformationMode>(transformMode)));
}

void* QImage_Scaled2(void* ptr, int width, int height, long long aspectRatioMode, long long transformMode)
{
	return new QImage(static_cast<QImage*>(ptr)->scaled(width, height, static_cast<Qt::AspectRatioMode>(aspectRatioMode), static_cast<Qt::TransformationMode>(transformMode)));
}

void* QImage_ScaledToHeight(void* ptr, int height, long long mode)
{
	return new QImage(static_cast<QImage*>(ptr)->scaledToHeight(height, static_cast<Qt::TransformationMode>(mode)));
}

void* QImage_ScaledToWidth(void* ptr, int width, long long mode)
{
	return new QImage(static_cast<QImage*>(ptr)->scaledToWidth(width, static_cast<Qt::TransformationMode>(mode)));
}

void* QImage_SmoothScaled(void* ptr, int w, int h)
{
	return new QImage(static_cast<QImage*>(ptr)->smoothScaled(w, h));
}

void* QImage_Transformed2(void* ptr, void* matrix, long long mode)
{
	return new QImage(static_cast<QImage*>(ptr)->transformed(*static_cast<QTransform*>(matrix), static_cast<Qt::TransformationMode>(mode)));
}

void* QImage_PixelFormat(void* ptr)
{
	return new QPixelFormat(static_cast<QImage*>(ptr)->pixelFormat());
}

void* QImage_Offset(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QImage*>(ptr)->offset(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QImage_Rect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QImage*>(ptr)->rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QImage_Size(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QImage*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QImage_Text(void* ptr, char* key)
{
	return ({ QByteArray t1f522b = static_cast<QImage*>(ptr)->text(QString(key)).toUtf8(); QtGui_PackedString { const_cast<char*>(t1f522b.prepend("WHITESPACE").constData()+10), t1f522b.size()-10 }; });
}

struct QtGui_PackedString QImage_TextKeys(void* ptr)
{
	return ({ QByteArray t71d2ff = static_cast<QImage*>(ptr)->textKeys().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t71d2ff.prepend("WHITESPACE").constData()+10), t71d2ff.size()-10 }; });
}

char QImage_AllGray(void* ptr)
{
	return static_cast<QImage*>(ptr)->allGray();
}

char QImage_HasAlphaChannel(void* ptr)
{
	return static_cast<QImage*>(ptr)->hasAlphaChannel();
}

char QImage_IsGrayscale(void* ptr)
{
	return static_cast<QImage*>(ptr)->isGrayscale();
}

char QImage_IsNull(void* ptr)
{
	return static_cast<QImage*>(ptr)->isNull();
}

char QImage_Save2(void* ptr, void* device, char* format, int quality)
{
	return static_cast<QImage*>(ptr)->save(static_cast<QIODevice*>(device), const_cast<const char*>(format), quality);
}

char QImage_Save(void* ptr, char* fileName, char* format, int quality)
{
	return static_cast<QImage*>(ptr)->save(QString(fileName), const_cast<const char*>(format), quality);
}

char QImage_Valid(void* ptr, void* pos)
{
	return static_cast<QImage*>(ptr)->valid(*static_cast<QPoint*>(pos));
}

char QImage_Valid2(void* ptr, int x, int y)
{
	return static_cast<QImage*>(ptr)->valid(x, y);
}

struct QtGui_PackedString QImage_Bits2(void* ptr)
{
	return ({ char* te11021 = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QImage*>(ptr)->bits()))); QtGui_PackedString { te11021, -1 }; });
}

struct QtGui_PackedString QImage_ConstBits(void* ptr)
{
	return ({ char* t467df0 = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QImage*>(ptr)->constBits()))); QtGui_PackedString { t467df0, -1 }; });
}

struct QtGui_PackedString QImage_ConstScanLine(void* ptr, int i)
{
	return ({ char* t2457d1 = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QImage*>(ptr)->constScanLine(i)))); QtGui_PackedString { t2457d1, -1 }; });
}

struct QtGui_PackedString QImage_ScanLine2(void* ptr, int i)
{
	return ({ char* t3248e5 = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QImage*>(ptr)->scanLine(i)))); QtGui_PackedString { t3248e5, -1 }; });
}

int QImage_BitPlaneCount(void* ptr)
{
	return static_cast<QImage*>(ptr)->bitPlaneCount();
}

int QImage_ByteCount(void* ptr)
{
	return static_cast<QImage*>(ptr)->byteCount();
}

int QImage_BytesPerLine(void* ptr)
{
	return static_cast<QImage*>(ptr)->bytesPerLine();
}

int QImage_DotsPerMeterX(void* ptr)
{
	return static_cast<QImage*>(ptr)->dotsPerMeterX();
}

int QImage_DotsPerMeterY(void* ptr)
{
	return static_cast<QImage*>(ptr)->dotsPerMeterY();
}

int QImage_PixelIndex(void* ptr, void* position)
{
	return static_cast<QImage*>(ptr)->pixelIndex(*static_cast<QPoint*>(position));
}

int QImage_PixelIndex2(void* ptr, int x, int y)
{
	return static_cast<QImage*>(ptr)->pixelIndex(x, y);
}

long long QImage_CacheKey(void* ptr)
{
	return static_cast<QImage*>(ptr)->cacheKey();
}

double QImage_DevicePixelRatio(void* ptr)
{
	return static_cast<QImage*>(ptr)->devicePixelRatio();
}

void* QImage_ToVariant(void* ptr)
{
	return new QVariant(*static_cast<QImage*>(ptr));
}

void* QImage___setColorTable_colors_newList(void* ptr)
{
	return new QVector<QRgb>;
}

void* QImage___convertToFormat_colorTable_newList2(void* ptr)
{
	return new QVector<QRgb>;
}

void* QImage___colorTable_newList(void* ptr)
{
	return new QVector<QRgb>;
}

void* QImage_PaintEngine(void* ptr)
{
	return static_cast<QImage*>(ptr)->paintEngine();
}

void* QImage_PaintEngineDefault(void* ptr)
{
		return static_cast<QImage*>(ptr)->QImage::paintEngine();
}

class MyQImageIOHandler: public QImageIOHandler
{
public:
	MyQImageIOHandler() : QImageIOHandler() {};
	bool jumpToImage(int imageNumber) { return callbackQImageIOHandler_JumpToImage(this, imageNumber) != 0; };
	bool jumpToNextImage() { return callbackQImageIOHandler_JumpToNextImage(this) != 0; };
	bool read(QImage * image) { return callbackQImageIOHandler_Read(this, image) != 0; };
	bool write(const QImage & image) { return callbackQImageIOHandler_Write(this, const_cast<QImage*>(&image)) != 0; };
	void setOption(QImageIOHandler::ImageOption option, const QVariant & value) { callbackQImageIOHandler_SetOption(this, option, const_cast<QVariant*>(&value)); };
	 ~MyQImageIOHandler() { callbackQImageIOHandler_DestroyQImageIOHandler(this); };
	QRect currentImageRect() const { return *static_cast<QRect*>(callbackQImageIOHandler_CurrentImageRect(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant option(QImageIOHandler::ImageOption option) const { return *static_cast<QVariant*>(callbackQImageIOHandler_Option(const_cast<void*>(static_cast<const void*>(this)), option)); };
	bool canRead() const { return callbackQImageIOHandler_CanRead(const_cast<void*>(static_cast<const void*>(this))) != 0; };
	bool supportsOption(QImageIOHandler::ImageOption option) const { return callbackQImageIOHandler_SupportsOption(const_cast<void*>(static_cast<const void*>(this)), option) != 0; };
	int currentImageNumber() const { return callbackQImageIOHandler_CurrentImageNumber(const_cast<void*>(static_cast<const void*>(this))); };
	int imageCount() const { return callbackQImageIOHandler_ImageCount(const_cast<void*>(static_cast<const void*>(this))); };
	int loopCount() const { return callbackQImageIOHandler_LoopCount(const_cast<void*>(static_cast<const void*>(this))); };
	int nextImageDelay() const { return callbackQImageIOHandler_NextImageDelay(const_cast<void*>(static_cast<const void*>(this))); };
};

void* QImageIOHandler_NewQImageIOHandler()
{
	return new MyQImageIOHandler();
}

char QImageIOHandler_JumpToImage(void* ptr, int imageNumber)
{
	return static_cast<QImageIOHandler*>(ptr)->jumpToImage(imageNumber);
}

char QImageIOHandler_JumpToImageDefault(void* ptr, int imageNumber)
{
		return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::jumpToImage(imageNumber);
}

char QImageIOHandler_JumpToNextImage(void* ptr)
{
	return static_cast<QImageIOHandler*>(ptr)->jumpToNextImage();
}

char QImageIOHandler_JumpToNextImageDefault(void* ptr)
{
		return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::jumpToNextImage();
}

char QImageIOHandler_Read(void* ptr, void* image)
{
	return static_cast<QImageIOHandler*>(ptr)->read(static_cast<QImage*>(image));
}

char QImageIOHandler_Write(void* ptr, void* image)
{
	return static_cast<QImageIOHandler*>(ptr)->write(*static_cast<QImage*>(image));
}

char QImageIOHandler_WriteDefault(void* ptr, void* image)
{
		return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::write(*static_cast<QImage*>(image));
}

void QImageIOHandler_SetDevice(void* ptr, void* device)
{
	static_cast<QImageIOHandler*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}

void QImageIOHandler_SetFormat(void* ptr, void* format)
{
	static_cast<QImageIOHandler*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}

void QImageIOHandler_SetOption(void* ptr, long long option, void* value)
{
	static_cast<QImageIOHandler*>(ptr)->setOption(static_cast<QImageIOHandler::ImageOption>(option), *static_cast<QVariant*>(value));
}

void QImageIOHandler_SetOptionDefault(void* ptr, long long option, void* value)
{
		static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::setOption(static_cast<QImageIOHandler::ImageOption>(option), *static_cast<QVariant*>(value));
}

void QImageIOHandler_DestroyQImageIOHandler(void* ptr)
{
	static_cast<QImageIOHandler*>(ptr)->~QImageIOHandler();
}

void QImageIOHandler_DestroyQImageIOHandlerDefault(void* ptr)
{

}

void* QImageIOHandler_Format(void* ptr)
{
	return new QByteArray(static_cast<QImageIOHandler*>(ptr)->format());
}

void* QImageIOHandler_Device(void* ptr)
{
	return static_cast<QImageIOHandler*>(ptr)->device();
}

void* QImageIOHandler_CurrentImageRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QImageIOHandler*>(ptr)->currentImageRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QImageIOHandler_CurrentImageRectDefault(void* ptr)
{
		return ({ QRect tmpValue = static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::currentImageRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QImageIOHandler_Option(void* ptr, long long option)
{
	return new QVariant(static_cast<QImageIOHandler*>(ptr)->option(static_cast<QImageIOHandler::ImageOption>(option)));
}

void* QImageIOHandler_OptionDefault(void* ptr, long long option)
{
		return new QVariant(static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::option(static_cast<QImageIOHandler::ImageOption>(option)));
}

char QImageIOHandler_CanRead(void* ptr)
{
	return static_cast<QImageIOHandler*>(ptr)->canRead();
}

char QImageIOHandler_SupportsOption(void* ptr, long long option)
{
	return static_cast<QImageIOHandler*>(ptr)->supportsOption(static_cast<QImageIOHandler::ImageOption>(option));
}

char QImageIOHandler_SupportsOptionDefault(void* ptr, long long option)
{
		return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::supportsOption(static_cast<QImageIOHandler::ImageOption>(option));
}

int QImageIOHandler_CurrentImageNumber(void* ptr)
{
	return static_cast<QImageIOHandler*>(ptr)->currentImageNumber();
}

int QImageIOHandler_CurrentImageNumberDefault(void* ptr)
{
		return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::currentImageNumber();
}

int QImageIOHandler_ImageCount(void* ptr)
{
	return static_cast<QImageIOHandler*>(ptr)->imageCount();
}

int QImageIOHandler_ImageCountDefault(void* ptr)
{
		return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::imageCount();
}

int QImageIOHandler_LoopCount(void* ptr)
{
	return static_cast<QImageIOHandler*>(ptr)->loopCount();
}

int QImageIOHandler_LoopCountDefault(void* ptr)
{
		return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::loopCount();
}

int QImageIOHandler_NextImageDelay(void* ptr)
{
	return static_cast<QImageIOHandler*>(ptr)->nextImageDelay();
}

int QImageIOHandler_NextImageDelayDefault(void* ptr)
{
		return static_cast<QImageIOHandler*>(ptr)->QImageIOHandler::nextImageDelay();
}

void QImageIOHandler_SetFormat2(void* ptr, void* format)
{
	static_cast<QImageIOHandler*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}

class MyQImageIOPlugin: public QImageIOPlugin
{
public:
	MyQImageIOPlugin(QObject *parent) : QImageIOPlugin(parent) {};
	 ~MyQImageIOPlugin() { callbackQImageIOPlugin_DestroyQImageIOPlugin(this); };
	Capabilities capabilities(QIODevice * device, const QByteArray & format) const { return static_cast<QImageIOPlugin::Capability>(callbackQImageIOPlugin_Capabilities(const_cast<void*>(static_cast<const void*>(this)), device, const_cast<QByteArray*>(&format))); };
	QImageIOHandler * create(QIODevice * device, const QByteArray & format) const { return static_cast<QImageIOHandler*>(callbackQImageIOPlugin_Create(const_cast<void*>(static_cast<const void*>(this)), device, const_cast<QByteArray*>(&format))); };
	bool event(QEvent * e) { return callbackQImageIOPlugin_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQImageIOPlugin_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQImageIOPlugin_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQImageIOPlugin_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQImageIOPlugin_CustomEvent(this, event); };
	void deleteLater() { callbackQImageIOPlugin_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQImageIOPlugin_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQImageIOPlugin_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQImageIOPlugin_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQImageIOPlugin_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQImageIOPlugin_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QImageIOPlugin_NewQImageIOPlugin(void* parent)
{
	return new MyQImageIOPlugin(static_cast<QObject*>(parent));
}

void QImageIOPlugin_DestroyQImageIOPlugin(void* ptr)
{
	static_cast<QImageIOPlugin*>(ptr)->~QImageIOPlugin();
}

void QImageIOPlugin_DestroyQImageIOPluginDefault(void* ptr)
{

}

long long QImageIOPlugin_Capabilities(void* ptr, void* device, void* format)
{
	return static_cast<QImageIOPlugin*>(ptr)->capabilities(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format));
}

void* QImageIOPlugin_Create(void* ptr, void* device, void* format)
{
	return static_cast<QImageIOPlugin*>(ptr)->create(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format));
}

void* QImageIOPlugin___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QImageIOPlugin___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QImageIOPlugin___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QImageIOPlugin___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QImageIOPlugin___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QImageIOPlugin___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QImageIOPlugin___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QImageIOPlugin___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QImageIOPlugin___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QImageIOPlugin___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QImageIOPlugin___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QImageIOPlugin___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QImageIOPlugin___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QImageIOPlugin___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QImageIOPlugin___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QImageIOPlugin_EventDefault(void* ptr, void* e)
{
		return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::event(static_cast<QEvent*>(e));
}

char QImageIOPlugin_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QImageIOPlugin_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::childEvent(static_cast<QChildEvent*>(event));
}

void QImageIOPlugin_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QImageIOPlugin_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::customEvent(static_cast<QEvent*>(event));
}

void QImageIOPlugin_DeleteLaterDefault(void* ptr)
{
		static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::deleteLater();
}

void QImageIOPlugin_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QImageIOPlugin_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QImageIOPlugin_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QImageIOPlugin*>(ptr)->QImageIOPlugin::metaObject());
}

void* QImageReader_QImageReader_ImageFormat3(void* device)
{
	return new QByteArray(QImageReader::imageFormat(static_cast<QIODevice*>(device)));
}

void* QImageReader_QImageReader_ImageFormat2(char* fileName)
{
	return new QByteArray(QImageReader::imageFormat(QString(fileName)));
}

void* QImageReader_Read(void* ptr)
{
	return new QImage(static_cast<QImageReader*>(ptr)->read());
}

void* QImageReader_NewQImageReader()
{
	return new QImageReader();
}

void* QImageReader_NewQImageReader2(void* device, void* format)
{
	return new QImageReader(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format));
}

void* QImageReader_NewQImageReader3(char* fileName, void* format)
{
	return new QImageReader(QString(fileName), *static_cast<QByteArray*>(format));
}

struct QtGui_PackedList QImageReader_QImageReader_SupportedImageFormats()
{
	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QImageReader::supportedImageFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QImageReader_QImageReader_SupportedMimeTypes()
{
	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QImageReader::supportedMimeTypes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

char QImageReader_JumpToImage(void* ptr, int imageNumber)
{
	return static_cast<QImageReader*>(ptr)->jumpToImage(imageNumber);
}

char QImageReader_JumpToNextImage(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->jumpToNextImage();
}

char QImageReader_Read2(void* ptr, void* image)
{
	return static_cast<QImageReader*>(ptr)->read(static_cast<QImage*>(image));
}

void QImageReader_SetAutoDetectImageFormat(void* ptr, char enabled)
{
	static_cast<QImageReader*>(ptr)->setAutoDetectImageFormat(enabled != 0);
}

void QImageReader_SetAutoTransform(void* ptr, char enabled)
{
	static_cast<QImageReader*>(ptr)->setAutoTransform(enabled != 0);
}

void QImageReader_SetBackgroundColor(void* ptr, void* color)
{
	static_cast<QImageReader*>(ptr)->setBackgroundColor(*static_cast<QColor*>(color));
}

void QImageReader_SetClipRect(void* ptr, void* rect)
{
	static_cast<QImageReader*>(ptr)->setClipRect(*static_cast<QRect*>(rect));
}

void QImageReader_SetDecideFormatFromContent(void* ptr, char ignored)
{
	static_cast<QImageReader*>(ptr)->setDecideFormatFromContent(ignored != 0);
}

void QImageReader_SetDevice(void* ptr, void* device)
{
	static_cast<QImageReader*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}

void QImageReader_SetFileName(void* ptr, char* fileName)
{
	static_cast<QImageReader*>(ptr)->setFileName(QString(fileName));
}

void QImageReader_SetFormat(void* ptr, void* format)
{
	static_cast<QImageReader*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}

void QImageReader_SetGamma(void* ptr, float gamma)
{
	static_cast<QImageReader*>(ptr)->setGamma(gamma);
}

void QImageReader_SetQuality(void* ptr, int quality)
{
	static_cast<QImageReader*>(ptr)->setQuality(quality);
}

void QImageReader_SetScaledClipRect(void* ptr, void* rect)
{
	static_cast<QImageReader*>(ptr)->setScaledClipRect(*static_cast<QRect*>(rect));
}

void QImageReader_SetScaledSize(void* ptr, void* size)
{
	static_cast<QImageReader*>(ptr)->setScaledSize(*static_cast<QSize*>(size));
}

void QImageReader_DestroyQImageReader(void* ptr)
{
	static_cast<QImageReader*>(ptr)->~QImageReader();
}

long long QImageReader_Error(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->error();
}

void* QImageReader_Format(void* ptr)
{
	return new QByteArray(static_cast<QImageReader*>(ptr)->format());
}

void* QImageReader_SubType(void* ptr)
{
	return new QByteArray(static_cast<QImageReader*>(ptr)->subType());
}

void* QImageReader_BackgroundColor(void* ptr)
{
	return new QColor(static_cast<QImageReader*>(ptr)->backgroundColor());
}

void* QImageReader_Device(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->device();
}

long long QImageReader_ImageFormat(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->imageFormat();
}

long long QImageReader_Transformation(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->transformation();
}

struct QtGui_PackedList QImageReader_SupportedSubTypes(void* ptr)
{
	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(static_cast<QImageReader*>(ptr)->supportedSubTypes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QImageReader_ClipRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QImageReader*>(ptr)->clipRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QImageReader_CurrentImageRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QImageReader*>(ptr)->currentImageRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QImageReader_ScaledClipRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QImageReader*>(ptr)->scaledClipRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QImageReader_ScaledSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QImageReader*>(ptr)->scaledSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QImageReader_Size(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QImageReader*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QImageReader_ErrorString(void* ptr)
{
	return ({ QByteArray t444465 = static_cast<QImageReader*>(ptr)->errorString().toUtf8(); QtGui_PackedString { const_cast<char*>(t444465.prepend("WHITESPACE").constData()+10), t444465.size()-10 }; });
}

struct QtGui_PackedString QImageReader_FileName(void* ptr)
{
	return ({ QByteArray t78ed9f = static_cast<QImageReader*>(ptr)->fileName().toUtf8(); QtGui_PackedString { const_cast<char*>(t78ed9f.prepend("WHITESPACE").constData()+10), t78ed9f.size()-10 }; });
}

struct QtGui_PackedString QImageReader_Text(void* ptr, char* key)
{
	return ({ QByteArray tbf8b9c = static_cast<QImageReader*>(ptr)->text(QString(key)).toUtf8(); QtGui_PackedString { const_cast<char*>(tbf8b9c.prepend("WHITESPACE").constData()+10), tbf8b9c.size()-10 }; });
}

struct QtGui_PackedString QImageReader_TextKeys(void* ptr)
{
	return ({ QByteArray t436ca8 = static_cast<QImageReader*>(ptr)->textKeys().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t436ca8.prepend("WHITESPACE").constData()+10), t436ca8.size()-10 }; });
}

char QImageReader_AutoDetectImageFormat(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->autoDetectImageFormat();
}

char QImageReader_AutoTransform(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->autoTransform();
}

char QImageReader_CanRead(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->canRead();
}

char QImageReader_DecideFormatFromContent(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->decideFormatFromContent();
}

char QImageReader_SupportsAnimation(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->supportsAnimation();
}

char QImageReader_SupportsOption(void* ptr, long long option)
{
	return static_cast<QImageReader*>(ptr)->supportsOption(static_cast<QImageIOHandler::ImageOption>(option));
}

float QImageReader_Gamma(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->gamma();
}

int QImageReader_CurrentImageNumber(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->currentImageNumber();
}

int QImageReader_ImageCount(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->imageCount();
}

int QImageReader_LoopCount(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->loopCount();
}

int QImageReader_NextImageDelay(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->nextImageDelay();
}

int QImageReader_Quality(void* ptr)
{
	return static_cast<QImageReader*>(ptr)->quality();
}

void* QImageReader___supportedImageFormats_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QImageReader___supportedImageFormats_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QImageReader___supportedImageFormats_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QImageReader___supportedMimeTypes_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QImageReader___supportedMimeTypes_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QImageReader___supportedMimeTypes_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QImageReader___supportedSubTypes_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QImageReader___supportedSubTypes_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QImageReader___supportedSubTypes_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QImageWriter_NewQImageWriter()
{
	return new QImageWriter();
}

void* QImageWriter_NewQImageWriter2(void* device, void* format)
{
	return new QImageWriter(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format));
}

void* QImageWriter_NewQImageWriter3(char* fileName, void* format)
{
	return new QImageWriter(QString(fileName), *static_cast<QByteArray*>(format));
}

struct QtGui_PackedList QImageWriter_QImageWriter_SupportedImageFormats()
{
	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QImageWriter::supportedImageFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QImageWriter_QImageWriter_SupportedMimeTypes()
{
	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QImageWriter::supportedMimeTypes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

char QImageWriter_Write(void* ptr, void* image)
{
	return static_cast<QImageWriter*>(ptr)->write(*static_cast<QImage*>(image));
}

void QImageWriter_SetCompression(void* ptr, int compression)
{
	static_cast<QImageWriter*>(ptr)->setCompression(compression);
}

void QImageWriter_SetDevice(void* ptr, void* device)
{
	static_cast<QImageWriter*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}

void QImageWriter_SetFileName(void* ptr, char* fileName)
{
	static_cast<QImageWriter*>(ptr)->setFileName(QString(fileName));
}

void QImageWriter_SetFormat(void* ptr, void* format)
{
	static_cast<QImageWriter*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}

void QImageWriter_SetGamma(void* ptr, float gamma)
{
	static_cast<QImageWriter*>(ptr)->setGamma(gamma);
}

void QImageWriter_SetOptimizedWrite(void* ptr, char optimize)
{
	static_cast<QImageWriter*>(ptr)->setOptimizedWrite(optimize != 0);
}

void QImageWriter_SetProgressiveScanWrite(void* ptr, char progressive)
{
	static_cast<QImageWriter*>(ptr)->setProgressiveScanWrite(progressive != 0);
}

void QImageWriter_SetQuality(void* ptr, int quality)
{
	static_cast<QImageWriter*>(ptr)->setQuality(quality);
}

void QImageWriter_SetSubType(void* ptr, void* ty)
{
	static_cast<QImageWriter*>(ptr)->setSubType(*static_cast<QByteArray*>(ty));
}

void QImageWriter_SetText(void* ptr, char* key, char* text)
{
	static_cast<QImageWriter*>(ptr)->setText(QString(key), QString(text));
}

void QImageWriter_SetTransformation(void* ptr, long long transform)
{
	static_cast<QImageWriter*>(ptr)->setTransformation(static_cast<QImageIOHandler::Transformation>(transform));
}

void QImageWriter_DestroyQImageWriter(void* ptr)
{
	static_cast<QImageWriter*>(ptr)->~QImageWriter();
}

long long QImageWriter_Error(void* ptr)
{
	return static_cast<QImageWriter*>(ptr)->error();
}

void* QImageWriter_Format(void* ptr)
{
	return new QByteArray(static_cast<QImageWriter*>(ptr)->format());
}

void* QImageWriter_SubType(void* ptr)
{
	return new QByteArray(static_cast<QImageWriter*>(ptr)->subType());
}

void* QImageWriter_Device(void* ptr)
{
	return static_cast<QImageWriter*>(ptr)->device();
}

long long QImageWriter_Transformation(void* ptr)
{
	return static_cast<QImageWriter*>(ptr)->transformation();
}

struct QtGui_PackedList QImageWriter_SupportedSubTypes(void* ptr)
{
	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(static_cast<QImageWriter*>(ptr)->supportedSubTypes()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedString QImageWriter_ErrorString(void* ptr)
{
	return ({ QByteArray t4f91d9 = static_cast<QImageWriter*>(ptr)->errorString().toUtf8(); QtGui_PackedString { const_cast<char*>(t4f91d9.prepend("WHITESPACE").constData()+10), t4f91d9.size()-10 }; });
}

struct QtGui_PackedString QImageWriter_FileName(void* ptr)
{
	return ({ QByteArray tb587a3 = static_cast<QImageWriter*>(ptr)->fileName().toUtf8(); QtGui_PackedString { const_cast<char*>(tb587a3.prepend("WHITESPACE").constData()+10), tb587a3.size()-10 }; });
}

char QImageWriter_CanWrite(void* ptr)
{
	return static_cast<QImageWriter*>(ptr)->canWrite();
}

char QImageWriter_OptimizedWrite(void* ptr)
{
	return static_cast<QImageWriter*>(ptr)->optimizedWrite();
}

char QImageWriter_ProgressiveScanWrite(void* ptr)
{
	return static_cast<QImageWriter*>(ptr)->progressiveScanWrite();
}

char QImageWriter_SupportsOption(void* ptr, long long option)
{
	return static_cast<QImageWriter*>(ptr)->supportsOption(static_cast<QImageIOHandler::ImageOption>(option));
}

float QImageWriter_Gamma(void* ptr)
{
	return static_cast<QImageWriter*>(ptr)->gamma();
}

int QImageWriter_Compression(void* ptr)
{
	return static_cast<QImageWriter*>(ptr)->compression();
}

int QImageWriter_Quality(void* ptr)
{
	return static_cast<QImageWriter*>(ptr)->quality();
}

void* QImageWriter___supportedImageFormats_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QImageWriter___supportedImageFormats_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QImageWriter___supportedImageFormats_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QImageWriter___supportedMimeTypes_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QImageWriter___supportedMimeTypes_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QImageWriter___supportedMimeTypes_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QImageWriter___supportedSubTypes_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QImageWriter___supportedSubTypes_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QImageWriter___supportedSubTypes_newList(void* ptr)
{
	return new QList<QByteArray>;
}

class MyQInputEvent: public QInputEvent
{
public:
};

long long QInputEvent_Modifiers(void* ptr)
{
	return static_cast<QInputEvent*>(ptr)->modifiers();
}

unsigned long QInputEvent_Timestamp(void* ptr)
{
	return static_cast<QInputEvent*>(ptr)->timestamp();
}

long long QInputEvent_ModState(void* ptr)
{
	return static_cast<QInputEvent*>(ptr)->modState;
}

void QInputEvent_SetModState(void* ptr, long long vqt)
{
	static_cast<QInputEvent*>(ptr)->modState = static_cast<Qt::KeyboardModifier>(vqt);
}

unsigned long QInputEvent_Ts(void* ptr)
{
	return static_cast<QInputEvent*>(ptr)->ts;
}

void QInputEvent_SetTs(void* ptr, unsigned long vul)
{
	static_cast<QInputEvent*>(ptr)->ts = vul;
}

class MyQInputMethod: public QInputMethod
{
public:
	void Signal_AnchorRectangleChanged() { callbackQInputMethod_AnchorRectangleChanged(this); };
	void Signal_AnimatingChanged() { callbackQInputMethod_AnimatingChanged(this); };
	void commit() { callbackQInputMethod_Commit(this); };
	void Signal_CursorRectangleChanged() { callbackQInputMethod_CursorRectangleChanged(this); };
	void hide() { callbackQInputMethod_Hide(this); };
	void Signal_InputDirectionChanged(Qt::LayoutDirection newDirection) { callbackQInputMethod_InputDirectionChanged(this, newDirection); };
	void Signal_InputItemClipRectangleChanged() { callbackQInputMethod_InputItemClipRectangleChanged(this); };
	void invokeAction(QInputMethod::Action a, int cursorPosition) { callbackQInputMethod_InvokeAction(this, a, cursorPosition); };
	void Signal_KeyboardRectangleChanged() { callbackQInputMethod_KeyboardRectangleChanged(this); };
	void Signal_LocaleChanged() { callbackQInputMethod_LocaleChanged(this); };
	void reset() { callbackQInputMethod_Reset(this); };
	void show() { callbackQInputMethod_Show(this); };
	void update(Qt::InputMethodQueries queries) { callbackQInputMethod_Update(this, queries); };
	void Signal_VisibleChanged() { callbackQInputMethod_VisibleChanged(this); };
	bool event(QEvent * e) { return callbackQInputMethod_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQInputMethod_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQInputMethod_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQInputMethod_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQInputMethod_CustomEvent(this, event); };
	void deleteLater() { callbackQInputMethod_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQInputMethod_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQInputMethod_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQInputMethod_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQInputMethod_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQInputMethod_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QInputMethod_QInputMethod_QueryFocusObject(long long query, void* argument)
{
	return new QVariant(QInputMethod::queryFocusObject(static_cast<Qt::InputMethodQuery>(query), *static_cast<QVariant*>(argument)));
}

void QInputMethod_ConnectAnchorRectangleChanged(void* ptr)
{
	QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::anchorRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_AnchorRectangleChanged));
}

void QInputMethod_DisconnectAnchorRectangleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::anchorRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_AnchorRectangleChanged));
}

void QInputMethod_AnchorRectangleChanged(void* ptr)
{
	static_cast<QInputMethod*>(ptr)->anchorRectangleChanged();
}

void QInputMethod_ConnectAnimatingChanged(void* ptr)
{
	QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::animatingChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_AnimatingChanged));
}

void QInputMethod_DisconnectAnimatingChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::animatingChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_AnimatingChanged));
}

void QInputMethod_AnimatingChanged(void* ptr)
{
	static_cast<QInputMethod*>(ptr)->animatingChanged();
}

void QInputMethod_Commit(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "commit");
}

void QInputMethod_CommitDefault(void* ptr)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::commit();
}

void QInputMethod_ConnectCursorRectangleChanged(void* ptr)
{
	QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::cursorRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_CursorRectangleChanged));
}

void QInputMethod_DisconnectCursorRectangleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::cursorRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_CursorRectangleChanged));
}

void QInputMethod_CursorRectangleChanged(void* ptr)
{
	static_cast<QInputMethod*>(ptr)->cursorRectangleChanged();
}

void QInputMethod_Hide(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "hide");
}

void QInputMethod_HideDefault(void* ptr)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::hide();
}

void QInputMethod_ConnectInputDirectionChanged(void* ptr)
{
	QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)(Qt::LayoutDirection)>(&QInputMethod::inputDirectionChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)(Qt::LayoutDirection)>(&MyQInputMethod::Signal_InputDirectionChanged));
}

void QInputMethod_DisconnectInputDirectionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)(Qt::LayoutDirection)>(&QInputMethod::inputDirectionChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)(Qt::LayoutDirection)>(&MyQInputMethod::Signal_InputDirectionChanged));
}

void QInputMethod_InputDirectionChanged(void* ptr, long long newDirection)
{
	static_cast<QInputMethod*>(ptr)->inputDirectionChanged(static_cast<Qt::LayoutDirection>(newDirection));
}

void QInputMethod_ConnectInputItemClipRectangleChanged(void* ptr)
{
	QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::inputItemClipRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_InputItemClipRectangleChanged));
}

void QInputMethod_DisconnectInputItemClipRectangleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::inputItemClipRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_InputItemClipRectangleChanged));
}

void QInputMethod_InputItemClipRectangleChanged(void* ptr)
{
	static_cast<QInputMethod*>(ptr)->inputItemClipRectangleChanged();
}

void QInputMethod_InvokeAction(void* ptr, long long a, int cursorPosition)
{
	QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "invokeAction", Q_ARG(QInputMethod::Action, static_cast<QInputMethod::Action>(a)), Q_ARG(int, cursorPosition));
}

void QInputMethod_InvokeActionDefault(void* ptr, long long a, int cursorPosition)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::invokeAction(static_cast<QInputMethod::Action>(a), cursorPosition);
}

void QInputMethod_ConnectKeyboardRectangleChanged(void* ptr)
{
	QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::keyboardRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_KeyboardRectangleChanged));
}

void QInputMethod_DisconnectKeyboardRectangleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::keyboardRectangleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_KeyboardRectangleChanged));
}

void QInputMethod_KeyboardRectangleChanged(void* ptr)
{
	static_cast<QInputMethod*>(ptr)->keyboardRectangleChanged();
}

void QInputMethod_ConnectLocaleChanged(void* ptr)
{
	QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::localeChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_LocaleChanged));
}

void QInputMethod_DisconnectLocaleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::localeChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_LocaleChanged));
}

void QInputMethod_LocaleChanged(void* ptr)
{
	static_cast<QInputMethod*>(ptr)->localeChanged();
}

void QInputMethod_Reset(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "reset");
}

void QInputMethod_ResetDefault(void* ptr)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::reset();
}

void QInputMethod_SetInputItemRectangle(void* ptr, void* rect)
{
	static_cast<QInputMethod*>(ptr)->setInputItemRectangle(*static_cast<QRectF*>(rect));
}

void QInputMethod_SetInputItemTransform(void* ptr, void* transform)
{
	static_cast<QInputMethod*>(ptr)->setInputItemTransform(*static_cast<QTransform*>(transform));
}

void QInputMethod_SetVisible(void* ptr, char visible)
{
	static_cast<QInputMethod*>(ptr)->setVisible(visible != 0);
}

void QInputMethod_Show(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "show");
}

void QInputMethod_ShowDefault(void* ptr)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::show();
}

void QInputMethod_Update(void* ptr, long long queries)
{
	QMetaObject::invokeMethod(static_cast<QInputMethod*>(ptr), "update", Q_ARG(Qt::InputMethodQuery, static_cast<Qt::InputMethodQuery>(queries)));
}

void QInputMethod_UpdateDefault(void* ptr, long long queries)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::update(static_cast<Qt::InputMethodQuery>(queries));
}

void QInputMethod_ConnectVisibleChanged(void* ptr)
{
	QObject::connect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::visibleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_VisibleChanged));
}

void QInputMethod_DisconnectVisibleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QInputMethod*>(ptr), static_cast<void (QInputMethod::*)()>(&QInputMethod::visibleChanged), static_cast<MyQInputMethod*>(ptr), static_cast<void (MyQInputMethod::*)()>(&MyQInputMethod::Signal_VisibleChanged));
}

void QInputMethod_VisibleChanged(void* ptr)
{
	static_cast<QInputMethod*>(ptr)->visibleChanged();
}

void* QInputMethod_Locale(void* ptr)
{
	return new QLocale(static_cast<QInputMethod*>(ptr)->locale());
}

void* QInputMethod_AnchorRectangle(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QInputMethod*>(ptr)->anchorRectangle(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QInputMethod_CursorRectangle(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QInputMethod*>(ptr)->cursorRectangle(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QInputMethod_InputItemClipRectangle(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QInputMethod*>(ptr)->inputItemClipRectangle(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QInputMethod_InputItemRectangle(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QInputMethod*>(ptr)->inputItemRectangle(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QInputMethod_KeyboardRectangle(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QInputMethod*>(ptr)->keyboardRectangle(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QInputMethod_InputItemTransform(void* ptr)
{
	return new QTransform(static_cast<QInputMethod*>(ptr)->inputItemTransform());
}

long long QInputMethod_InputDirection(void* ptr)
{
	return static_cast<QInputMethod*>(ptr)->inputDirection();
}

char QInputMethod_IsAnimating(void* ptr)
{
	return static_cast<QInputMethod*>(ptr)->isAnimating();
}

char QInputMethod_IsVisible(void* ptr)
{
	return static_cast<QInputMethod*>(ptr)->isVisible();
}

void* QInputMethod___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QInputMethod___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QInputMethod___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QInputMethod___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QInputMethod___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QInputMethod___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QInputMethod___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QInputMethod___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QInputMethod___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QInputMethod___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QInputMethod___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QInputMethod___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QInputMethod___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QInputMethod___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QInputMethod___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QInputMethod_EventDefault(void* ptr, void* e)
{
		return static_cast<QInputMethod*>(ptr)->QInputMethod::event(static_cast<QEvent*>(e));
}

char QInputMethod_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QInputMethod*>(ptr)->QInputMethod::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QInputMethod*>(ptr)->QInputMethod::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QInputMethod*>(ptr)->QInputMethod::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QInputMethod*>(ptr)->QInputMethod::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QInputMethod*>(ptr)->QInputMethod::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QInputMethod_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::childEvent(static_cast<QChildEvent*>(event));
}

void QInputMethod_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QInputMethod_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::customEvent(static_cast<QEvent*>(event));
}

void QInputMethod_DeleteLaterDefault(void* ptr)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::deleteLater();
}

void QInputMethod_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QInputMethod_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QInputMethod*>(ptr)->QInputMethod::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QInputMethod_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QInputMethod*>(ptr)->QInputMethod::metaObject());
}

class MyQInputMethodEvent: public QInputMethodEvent
{
public:
	MyQInputMethodEvent(const QInputMethodEvent &other) : QInputMethodEvent(other) {};
	MyQInputMethodEvent() : QInputMethodEvent() {};
};

void* QInputMethodEvent_NewQInputMethodEvent3(void* other)
{
	return new MyQInputMethodEvent(*static_cast<QInputMethodEvent*>(other));
}

void QInputMethodEvent_SetCommitString(void* ptr, char* commitString, int replaceFrom, int replaceLength)
{
	static_cast<QInputMethodEvent*>(ptr)->setCommitString(QString(commitString), replaceFrom, replaceLength);
}

void QInputMethodEvent_DestroyQInputMethodEvent(void* ptr)
{
	static_cast<QInputMethodEvent*>(ptr)->~QInputMethodEvent();
}

void* QInputMethodEvent_NewQInputMethodEvent()
{
	return new MyQInputMethodEvent();
}

struct QtGui_PackedString QInputMethodEvent_CommitString(void* ptr)
{
	return ({ QByteArray t69832e = static_cast<QInputMethodEvent*>(ptr)->commitString().toUtf8(); QtGui_PackedString { const_cast<char*>(t69832e.prepend("WHITESPACE").constData()+10), t69832e.size()-10 }; });
}

struct QtGui_PackedString QInputMethodEvent_PreeditString(void* ptr)
{
	return ({ QByteArray t9860e5 = static_cast<QInputMethodEvent*>(ptr)->preeditString().toUtf8(); QtGui_PackedString { const_cast<char*>(t9860e5.prepend("WHITESPACE").constData()+10), t9860e5.size()-10 }; });
}

int QInputMethodEvent_ReplacementLength(void* ptr)
{
	return static_cast<QInputMethodEvent*>(ptr)->replacementLength();
}

int QInputMethodEvent_ReplacementStart(void* ptr)
{
	return static_cast<QInputMethodEvent*>(ptr)->replacementStart();
}

class MyQInputMethodQueryEvent: public QInputMethodQueryEvent
{
public:
	MyQInputMethodQueryEvent(Qt::InputMethodQueries queries) : QInputMethodQueryEvent(queries) {};
};

void* QInputMethodQueryEvent_NewQInputMethodQueryEvent(long long queries)
{
	return new MyQInputMethodQueryEvent(static_cast<Qt::InputMethodQuery>(queries));
}

void QInputMethodQueryEvent_SetValue(void* ptr, long long query, void* value)
{
	static_cast<QInputMethodQueryEvent*>(ptr)->setValue(static_cast<Qt::InputMethodQuery>(query), *static_cast<QVariant*>(value));
}

void* QInputMethodQueryEvent_Value(void* ptr, long long query)
{
	return new QVariant(static_cast<QInputMethodQueryEvent*>(ptr)->value(static_cast<Qt::InputMethodQuery>(query)));
}

long long QInputMethodQueryEvent_Queries(void* ptr)
{
	return static_cast<QInputMethodQueryEvent*>(ptr)->queries();
}

class MyQIntValidator: public QIntValidator
{
public:
	MyQIntValidator(QObject *parent) : QIntValidator(parent) {};
	MyQIntValidator(int minimum, int maximum, QObject *parent) : QIntValidator(minimum, maximum, parent) {};
	void setRange(int bottom, int top) { callbackQIntValidator_SetRange(this, bottom, top); };
	QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQIntValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
	void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	void Signal_Changed() { callbackQValidator_Changed(this); };
	bool event(QEvent * e) { return callbackQValidator_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQValidator_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQValidator_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQValidator_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQValidator_CustomEvent(this, event); };
	void deleteLater() { callbackQValidator_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQValidator_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQValidator_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQValidator_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQValidator_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQValidator_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QIntValidator_NewQIntValidator(void* parent)
{
	return new MyQIntValidator(static_cast<QObject*>(parent));
}

void* QIntValidator_NewQIntValidator2(int minimum, int maximum, void* parent)
{
	return new MyQIntValidator(minimum, maximum, static_cast<QObject*>(parent));
}

void QIntValidator_SetBottom(void* ptr, int vin)
{
	static_cast<QIntValidator*>(ptr)->setBottom(vin);
}

void QIntValidator_SetRange(void* ptr, int bottom, int top)
{
	static_cast<QIntValidator*>(ptr)->setRange(bottom, top);
}

void QIntValidator_SetRangeDefault(void* ptr, int bottom, int top)
{
		static_cast<QIntValidator*>(ptr)->QIntValidator::setRange(bottom, top);
}

void QIntValidator_SetTop(void* ptr, int vin)
{
	static_cast<QIntValidator*>(ptr)->setTop(vin);
}

void QIntValidator_DestroyQIntValidator(void* ptr)
{
	static_cast<QIntValidator*>(ptr)->~QIntValidator();
}

long long QIntValidator_Validate(void* ptr, char* input, int pos)
{
	return static_cast<QIntValidator*>(ptr)->validate(*(new QString(input)), pos);
}

long long QIntValidator_ValidateDefault(void* ptr, char* input, int pos)
{
		return static_cast<QIntValidator*>(ptr)->QIntValidator::validate(*(new QString(input)), pos);
}

int QIntValidator_Bottom(void* ptr)
{
	return static_cast<QIntValidator*>(ptr)->bottom();
}

int QIntValidator_Top(void* ptr)
{
	return static_cast<QIntValidator*>(ptr)->top();
}

class MyQKeyEvent: public QKeyEvent
{
public:
	MyQKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString &text, bool autorep, ushort count) : QKeyEvent(type, key, modifiers, text, autorep, count) {};
	MyQKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers, const QString &text, bool autorep, ushort count) : QKeyEvent(type, key, modifiers, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count) {};
};

void* QKeyEvent_NewQKeyEvent(long long ty, int key, long long modifiers, char* text, char autorep, unsigned short count)
{
	return new MyQKeyEvent(static_cast<QEvent::Type>(ty), key, static_cast<Qt::KeyboardModifier>(modifiers), QString(text), autorep != 0, count);
}

void* QKeyEvent_NewQKeyEvent2(long long ty, int key, long long modifiers, unsigned int nativeScanCode, unsigned int nativeVirtualKey, unsigned int nativeModifiers, char* text, char autorep, unsigned short count)
{
	return new MyQKeyEvent(static_cast<QEvent::Type>(ty), key, static_cast<Qt::KeyboardModifier>(modifiers), nativeScanCode, nativeVirtualKey, nativeModifiers, QString(text), autorep != 0, count);
}

struct QtGui_PackedString QKeyEvent_Text(void* ptr)
{
	return ({ QByteArray tac962f = static_cast<QKeyEvent*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(tac962f.prepend("WHITESPACE").constData()+10), tac962f.size()-10 }; });
}

char QKeyEvent_IsAutoRepeat(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->isAutoRepeat();
}

char QKeyEvent_Matches(void* ptr, long long key)
{
	return static_cast<QKeyEvent*>(ptr)->matches(static_cast<QKeySequence::StandardKey>(key));
}

int QKeyEvent_Count(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->count();
}

int QKeyEvent_Key(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->key();
}

unsigned int QKeyEvent_NativeModifiers(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->nativeModifiers();
}

unsigned int QKeyEvent_NativeScanCode(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->nativeScanCode();
}

unsigned int QKeyEvent_NativeVirtualKey(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->nativeVirtualKey();
}

unsigned short QKeyEvent_C(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->c;
}

void QKeyEvent_SetC(void* ptr, unsigned short vus)
{
	static_cast<QKeyEvent*>(ptr)->c = vus;
}

int QKeyEvent_K(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->k;
}

void QKeyEvent_SetK(void* ptr, int vin)
{
	static_cast<QKeyEvent*>(ptr)->k = vin;
}

unsigned int QKeyEvent_NModifiers(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->nModifiers;
}

void QKeyEvent_SetNModifiers(void* ptr, unsigned int vqu)
{
	static_cast<QKeyEvent*>(ptr)->nModifiers = vqu;
}

unsigned int QKeyEvent_NScanCode(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->nScanCode;
}

void QKeyEvent_SetNScanCode(void* ptr, unsigned int vqu)
{
	static_cast<QKeyEvent*>(ptr)->nScanCode = vqu;
}

unsigned int QKeyEvent_NVirtualKey(void* ptr)
{
	return static_cast<QKeyEvent*>(ptr)->nVirtualKey;
}

void QKeyEvent_SetNVirtualKey(void* ptr, unsigned int vqu)
{
	static_cast<QKeyEvent*>(ptr)->nVirtualKey = vqu;
}

struct QtGui_PackedString QKeyEvent_Txt(void* ptr)
{
	return ({ QByteArray t9192bb = static_cast<QKeyEvent*>(ptr)->txt.toUtf8(); QtGui_PackedString { const_cast<char*>(t9192bb.prepend("WHITESPACE").constData()+10), t9192bb.size()-10 }; });
}

void QKeyEvent_SetTxt(void* ptr, char* vqs)
{
	static_cast<QKeyEvent*>(ptr)->txt = QString(vqs);
}

void* QKeySequence_QKeySequence_FromString(char* str, long long format)
{
	return new QKeySequence(QKeySequence::fromString(QString(str), static_cast<QKeySequence::SequenceFormat>(format)));
}

void* QKeySequence_QKeySequence_Mnemonic(char* text)
{
	return new QKeySequence(QKeySequence::mnemonic(QString(text)));
}

void* QKeySequence_NewQKeySequence()
{
	return new QKeySequence();
}

void* QKeySequence_NewQKeySequence5(long long key)
{
	return new QKeySequence(static_cast<QKeySequence::StandardKey>(key));
}

void* QKeySequence_NewQKeySequence4(void* keysequence)
{
	return new QKeySequence(*static_cast<QKeySequence*>(keysequence));
}

void* QKeySequence_NewQKeySequence2(char* key, long long format)
{
	return new QKeySequence(QString(key), static_cast<QKeySequence::SequenceFormat>(format));
}

void* QKeySequence_NewQKeySequence3(int k1, int k2, int k3, int k4)
{
	return new QKeySequence(k1, k2, k3, k4);
}

struct QtGui_PackedList QKeySequence_QKeySequence_KeyBindings(long long key)
{
	return ({ QList<QKeySequence>* tmpValue = new QList<QKeySequence>(QKeySequence::keyBindings(static_cast<QKeySequence::StandardKey>(key))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QKeySequence_QKeySequence_ListFromString(char* str, long long format)
{
	return ({ QList<QKeySequence>* tmpValue = new QList<QKeySequence>(QKeySequence::listFromString(QString(str), static_cast<QKeySequence::SequenceFormat>(format))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedString QKeySequence_QKeySequence_ListToString(void* list, long long format)
{
	return ({ QByteArray tdd68e7 = QKeySequence::listToString(*static_cast<QList<QKeySequence>*>(list), static_cast<QKeySequence::SequenceFormat>(format)).toUtf8(); QtGui_PackedString { const_cast<char*>(tdd68e7.prepend("WHITESPACE").constData()+10), tdd68e7.size()-10 }; });
}

void QKeySequence_Swap(void* ptr, void* other)
{
	static_cast<QKeySequence*>(ptr)->swap(*static_cast<QKeySequence*>(other));
}

void QKeySequence_DestroyQKeySequence(void* ptr)
{
	static_cast<QKeySequence*>(ptr)->~QKeySequence();
}

struct QtGui_PackedString QKeySequence_ToString(void* ptr, long long format)
{
	return ({ QByteArray t3bf8a8 = static_cast<QKeySequence*>(ptr)->toString(static_cast<QKeySequence::SequenceFormat>(format)).toUtf8(); QtGui_PackedString { const_cast<char*>(t3bf8a8.prepend("WHITESPACE").constData()+10), t3bf8a8.size()-10 }; });
}

long long QKeySequence_Matches(void* ptr, void* seq)
{
	return static_cast<QKeySequence*>(ptr)->matches(*static_cast<QKeySequence*>(seq));
}

char QKeySequence_IsEmpty(void* ptr)
{
	return static_cast<QKeySequence*>(ptr)->isEmpty();
}

int QKeySequence_Count(void* ptr)
{
	return static_cast<QKeySequence*>(ptr)->count();
}

void* QKeySequence___keyBindings_atList(void* ptr, int i)
{
	return new QKeySequence(static_cast<QList<QKeySequence>*>(ptr)->at(i));
}

void QKeySequence___keyBindings_setList(void* ptr, void* i)
{
	static_cast<QList<QKeySequence>*>(ptr)->append(*static_cast<QKeySequence*>(i));
}

void* QKeySequence___keyBindings_newList(void* ptr)
{
	return new QList<QKeySequence>;
}

void* QKeySequence___listFromString_atList(void* ptr, int i)
{
	return new QKeySequence(static_cast<QList<QKeySequence>*>(ptr)->at(i));
}

void QKeySequence___listFromString_setList(void* ptr, void* i)
{
	static_cast<QList<QKeySequence>*>(ptr)->append(*static_cast<QKeySequence*>(i));
}

void* QKeySequence___listFromString_newList(void* ptr)
{
	return new QList<QKeySequence>;
}

void* QKeySequence___listToString_list_atList(void* ptr, int i)
{
	return new QKeySequence(static_cast<QList<QKeySequence>*>(ptr)->at(i));
}

void QKeySequence___listToString_list_setList(void* ptr, void* i)
{
	static_cast<QList<QKeySequence>*>(ptr)->append(*static_cast<QKeySequence*>(i));
}

void* QKeySequence___listToString_list_newList(void* ptr)
{
	return new QList<QKeySequence>;
}

void* QLinearGradient_NewQLinearGradient()
{
	return new QLinearGradient();
}

void* QLinearGradient_NewQLinearGradient2(void* start, void* finalStop)
{
	return new QLinearGradient(*static_cast<QPointF*>(start), *static_cast<QPointF*>(finalStop));
}

void* QLinearGradient_NewQLinearGradient3(double x1, double y1, double x2, double y2)
{
	return new QLinearGradient(x1, y1, x2, y2);
}

void QLinearGradient_SetFinalStop(void* ptr, void* stop)
{
	static_cast<QLinearGradient*>(ptr)->setFinalStop(*static_cast<QPointF*>(stop));
}

void QLinearGradient_SetFinalStop2(void* ptr, double x, double y)
{
	static_cast<QLinearGradient*>(ptr)->setFinalStop(x, y);
}

void QLinearGradient_SetStart(void* ptr, void* start)
{
	static_cast<QLinearGradient*>(ptr)->setStart(*static_cast<QPointF*>(start));
}

void QLinearGradient_SetStart2(void* ptr, double x, double y)
{
	static_cast<QLinearGradient*>(ptr)->setStart(x, y);
}

void* QLinearGradient_FinalStop(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QLinearGradient*>(ptr)->finalStop(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QLinearGradient_Start(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QLinearGradient*>(ptr)->start(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QMatrix4x4_NewQMatrix4x4()
{
	return new QMatrix4x4();
}

void* QMatrix4x4_NewQMatrix4x47(void* transform)
{
	return new QMatrix4x4(*static_cast<QTransform*>(transform));
}

void* QMatrix4x4_NewQMatrix4x43(float values)
{
	return new QMatrix4x4(const_cast<const float*>(&values));
}

void* QMatrix4x4_NewQMatrix4x44(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
	return new QMatrix4x4(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
}

float QMatrix4x4_Data(void* ptr)
{
	return *static_cast<QMatrix4x4*>(ptr)->data();
}

void QMatrix4x4_Fill(void* ptr, float value)
{
	static_cast<QMatrix4x4*>(ptr)->fill(value);
}

void QMatrix4x4_Frustum(void* ptr, float left, float right, float bottom, float top, float nearPlane, float farPlane)
{
	static_cast<QMatrix4x4*>(ptr)->frustum(left, right, bottom, top, nearPlane, farPlane);
}

void QMatrix4x4_LookAt(void* ptr, void* eye, void* center, void* up)
{
	static_cast<QMatrix4x4*>(ptr)->lookAt(*static_cast<QVector3D*>(eye), *static_cast<QVector3D*>(center), *static_cast<QVector3D*>(up));
}

void QMatrix4x4_Optimize(void* ptr)
{
	static_cast<QMatrix4x4*>(ptr)->optimize();
}

void QMatrix4x4_Ortho3(void* ptr, void* rect)
{
	static_cast<QMatrix4x4*>(ptr)->ortho(*static_cast<QRect*>(rect));
}

void QMatrix4x4_Ortho2(void* ptr, void* rect)
{
	static_cast<QMatrix4x4*>(ptr)->ortho(*static_cast<QRectF*>(rect));
}

void QMatrix4x4_Ortho(void* ptr, float left, float right, float bottom, float top, float nearPlane, float farPlane)
{
	static_cast<QMatrix4x4*>(ptr)->ortho(left, right, bottom, top, nearPlane, farPlane);
}

void QMatrix4x4_Perspective(void* ptr, float verticalAngle, float aspectRatio, float nearPlane, float farPlane)
{
	static_cast<QMatrix4x4*>(ptr)->perspective(verticalAngle, aspectRatio, nearPlane, farPlane);
}

void QMatrix4x4_Rotate3(void* ptr, void* quaternion)
{
	static_cast<QMatrix4x4*>(ptr)->rotate(*static_cast<QQuaternion*>(quaternion));
}

void QMatrix4x4_Rotate(void* ptr, float angle, void* vector)
{
	static_cast<QMatrix4x4*>(ptr)->rotate(angle, *static_cast<QVector3D*>(vector));
}

void QMatrix4x4_Rotate2(void* ptr, float angle, float x, float y, float z)
{
	static_cast<QMatrix4x4*>(ptr)->rotate(angle, x, y, z);
}

void QMatrix4x4_Scale(void* ptr, void* vector)
{
	static_cast<QMatrix4x4*>(ptr)->scale(*static_cast<QVector3D*>(vector));
}

void QMatrix4x4_Scale4(void* ptr, float factor)
{
	static_cast<QMatrix4x4*>(ptr)->scale(factor);
}

void QMatrix4x4_Scale2(void* ptr, float x, float y)
{
	static_cast<QMatrix4x4*>(ptr)->scale(x, y);
}

void QMatrix4x4_Scale3(void* ptr, float x, float y, float z)
{
	static_cast<QMatrix4x4*>(ptr)->scale(x, y, z);
}

void QMatrix4x4_SetColumn(void* ptr, int index, void* value)
{
	static_cast<QMatrix4x4*>(ptr)->setColumn(index, *static_cast<QVector4D*>(value));
}

void QMatrix4x4_SetRow(void* ptr, int index, void* value)
{
	static_cast<QMatrix4x4*>(ptr)->setRow(index, *static_cast<QVector4D*>(value));
}

void QMatrix4x4_SetToIdentity(void* ptr)
{
	static_cast<QMatrix4x4*>(ptr)->setToIdentity();
}

void QMatrix4x4_Translate(void* ptr, void* vector)
{
	static_cast<QMatrix4x4*>(ptr)->translate(*static_cast<QVector3D*>(vector));
}

void QMatrix4x4_Translate2(void* ptr, float x, float y)
{
	static_cast<QMatrix4x4*>(ptr)->translate(x, y);
}

void QMatrix4x4_Translate3(void* ptr, float x, float y, float z)
{
	static_cast<QMatrix4x4*>(ptr)->translate(x, y, z);
}

void QMatrix4x4_Viewport2(void* ptr, void* rect)
{
	static_cast<QMatrix4x4*>(ptr)->viewport(*static_cast<QRectF*>(rect));
}

void QMatrix4x4_Viewport(void* ptr, float left, float bottom, float width, float height, float nearPlane, float farPlane)
{
	static_cast<QMatrix4x4*>(ptr)->viewport(left, bottom, width, height, nearPlane, farPlane);
}

void* QMatrix4x4_Inverted(void* ptr, char invertible)
{
	return new QMatrix4x4(static_cast<QMatrix4x4*>(ptr)->inverted(NULL));
}

void* QMatrix4x4_Transposed(void* ptr)
{
	return new QMatrix4x4(static_cast<QMatrix4x4*>(ptr)->transposed());
}

void* QMatrix4x4_Map(void* ptr, void* point)
{
	return ({ QPoint tmpValue = static_cast<QMatrix4x4*>(ptr)->map(*static_cast<QPoint*>(point)); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QMatrix4x4_Map2(void* ptr, void* point)
{
	return ({ QPointF tmpValue = static_cast<QMatrix4x4*>(ptr)->map(*static_cast<QPointF*>(point)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QMatrix4x4_MapRect(void* ptr, void* rect)
{
	return ({ QRect tmpValue = static_cast<QMatrix4x4*>(ptr)->mapRect(*static_cast<QRect*>(rect)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QMatrix4x4_MapRect2(void* ptr, void* rect)
{
	return ({ QRectF tmpValue = static_cast<QMatrix4x4*>(ptr)->mapRect(*static_cast<QRectF*>(rect)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QMatrix4x4_ToTransform(void* ptr)
{
	return new QTransform(static_cast<QMatrix4x4*>(ptr)->toTransform());
}

void* QMatrix4x4_ToTransform2(void* ptr, float distanceToPlane)
{
	return new QTransform(static_cast<QMatrix4x4*>(ptr)->toTransform(distanceToPlane));
}

void* QMatrix4x4_Map3(void* ptr, void* point)
{
	return new QVector3D(static_cast<QMatrix4x4*>(ptr)->map(*static_cast<QVector3D*>(point)));
}

void* QMatrix4x4_MapVector(void* ptr, void* vector)
{
	return new QVector3D(static_cast<QMatrix4x4*>(ptr)->mapVector(*static_cast<QVector3D*>(vector)));
}

void* QMatrix4x4_Column(void* ptr, int index)
{
	return new QVector4D(static_cast<QMatrix4x4*>(ptr)->column(index));
}

void* QMatrix4x4_Map4(void* ptr, void* point)
{
	return new QVector4D(static_cast<QMatrix4x4*>(ptr)->map(*static_cast<QVector4D*>(point)));
}

void* QMatrix4x4_Row(void* ptr, int index)
{
	return new QVector4D(static_cast<QMatrix4x4*>(ptr)->row(index));
}

char QMatrix4x4_IsAffine(void* ptr)
{
	return static_cast<QMatrix4x4*>(ptr)->isAffine();
}

char QMatrix4x4_IsIdentity(void* ptr)
{
	return static_cast<QMatrix4x4*>(ptr)->isIdentity();
}

float QMatrix4x4_ConstData(void* ptr)
{
	return *static_cast<QMatrix4x4*>(ptr)->constData();
}

float QMatrix4x4_Data2(void* ptr)
{
	return *static_cast<QMatrix4x4*>(ptr)->data();
}

double QMatrix4x4_Determinant(void* ptr)
{
	return static_cast<QMatrix4x4*>(ptr)->determinant();
}

void QMatrix4x4_CopyDataTo(void* ptr, float values)
{
	static_cast<QMatrix4x4*>(ptr)->copyDataTo(&values);
}

class MyQMouseEvent: public QMouseEvent
{
public:
	MyQMouseEvent(Type type, const QPointF &localPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) : QMouseEvent(type, localPos, button, buttons, modifiers) {};
	MyQMouseEvent(Type type, const QPointF &localPos, const QPointF &screenPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) : QMouseEvent(type, localPos, screenPos, button, buttons, modifiers) {};
	MyQMouseEvent(Type type, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) : QMouseEvent(type, localPos, windowPos, screenPos, button, buttons, modifiers) {};
	MyQMouseEvent(Type type, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source) : QMouseEvent(type, localPos, windowPos, screenPos, button, buttons, modifiers, source) {};
};

void* QMouseEvent_NewQMouseEvent(long long ty, void* localPos, long long button, long long buttons, long long modifiers)
{
	return new MyQMouseEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(localPos), static_cast<Qt::MouseButton>(button), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers));
}

void* QMouseEvent_NewQMouseEvent2(long long ty, void* localPos, void* screenPos, long long button, long long buttons, long long modifiers)
{
	return new MyQMouseEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(localPos), *static_cast<QPointF*>(screenPos), static_cast<Qt::MouseButton>(button), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers));
}

void* QMouseEvent_NewQMouseEvent3(long long ty, void* localPos, void* windowPos, void* screenPos, long long button, long long buttons, long long modifiers)
{
	return new MyQMouseEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(localPos), *static_cast<QPointF*>(windowPos), *static_cast<QPointF*>(screenPos), static_cast<Qt::MouseButton>(button), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers));
}

void* QMouseEvent_NewQMouseEvent4(long long ty, void* localPos, void* windowPos, void* screenPos, long long button, long long buttons, long long modifiers, long long source)
{
	return new MyQMouseEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(localPos), *static_cast<QPointF*>(windowPos), *static_cast<QPointF*>(screenPos), static_cast<Qt::MouseButton>(button), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<Qt::MouseEventSource>(source));
}

void* QMouseEvent_GlobalPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QMouseEvent*>(ptr)->globalPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QMouseEvent_Pos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QMouseEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

long long QMouseEvent_Button(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->button();
}

long long QMouseEvent_Buttons(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->buttons();
}

long long QMouseEvent_Flags(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->flags();
}

long long QMouseEvent_Source(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->source();
}

void* QMouseEvent_LocalPos(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QMouseEvent*>(ptr)->localPos());
}

void* QMouseEvent_ScreenPos(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QMouseEvent*>(ptr)->screenPos());
}

void* QMouseEvent_WindowPos(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QMouseEvent*>(ptr)->windowPos());
}

int QMouseEvent_GlobalX(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->globalX();
}

int QMouseEvent_GlobalY(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->globalY();
}

int QMouseEvent_X(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->x();
}

int QMouseEvent_Y(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->y();
}

long long QMouseEvent_B(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->b;
}

void QMouseEvent_SetB(void* ptr, long long vqt)
{
	static_cast<QMouseEvent*>(ptr)->b = static_cast<Qt::MouseButton>(vqt);
}

int QMouseEvent_Caps(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->caps;
}

void QMouseEvent_SetCaps(void* ptr, int vin)
{
	static_cast<QMouseEvent*>(ptr)->caps = vin;
}

long long QMouseEvent_MouseState(void* ptr)
{
	return static_cast<QMouseEvent*>(ptr)->mouseState;
}

void QMouseEvent_SetMouseState(void* ptr, long long vqt)
{
	static_cast<QMouseEvent*>(ptr)->mouseState = static_cast<Qt::MouseButton>(vqt);
}

void* QMouseEvent_Velocity(void* ptr)
{
	return new QVector2D(static_cast<QMouseEvent*>(ptr)->velocity);
}

void QMouseEvent_SetVelocity(void* ptr, void* vqv)
{
	static_cast<QMouseEvent*>(ptr)->velocity = *static_cast<QVector2D*>(vqv);
}

class MyQMoveEvent: public QMoveEvent
{
public:
	MyQMoveEvent(const QPoint &pos, const QPoint &oldPos) : QMoveEvent(pos, oldPos) {};
};

void* QMoveEvent_NewQMoveEvent(void* pos, void* oldPos)
{
	return new MyQMoveEvent(*static_cast<QPoint*>(pos), *static_cast<QPoint*>(oldPos));
}

void* QMoveEvent_OldPos(void* ptr)
{
	return const_cast<QPoint*>(&static_cast<QMoveEvent*>(ptr)->oldPos());
}

void* QMoveEvent_Pos(void* ptr)
{
	return const_cast<QPoint*>(&static_cast<QMoveEvent*>(ptr)->pos());
}

class MyQMovie: public QMovie
{
public:
	MyQMovie(QIODevice *device, const QByteArray &format, QObject *parent) : QMovie(device, format, parent) {};
	MyQMovie(QObject *parent) : QMovie(parent) {};
	MyQMovie(const QString &fileName, const QByteArray &format, QObject *parent) : QMovie(fileName, format, parent) {};
	bool jumpToNextFrame() { return callbackQMovie_JumpToNextFrame(this) != 0; };
	void Signal_Error(QImageReader::ImageReaderError error) { callbackQMovie_Error(this, error); };
	void Signal_Finished() { callbackQMovie_Finished(this); };
	void Signal_FrameChanged(int frameNumber) { callbackQMovie_FrameChanged(this, frameNumber); };
	void Signal_Resized(const QSize & size) { callbackQMovie_Resized(this, const_cast<QSize*>(&size)); };
	void setPaused(bool paused) { callbackQMovie_SetPaused(this, paused); };
	void setSpeed(int percentSpeed) { callbackQMovie_SetSpeed(this, percentSpeed); };
	void start() { callbackQMovie_Start(this); };
	void Signal_Started() { callbackQMovie_Started(this); };
	void Signal_StateChanged(QMovie::MovieState state) { callbackQMovie_StateChanged(this, state); };
	void stop() { callbackQMovie_Stop(this); };
	void Signal_Updated(const QRect & rect) { callbackQMovie_Updated(this, const_cast<QRect*>(&rect)); };
	bool event(QEvent * e) { return callbackQMovie_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQMovie_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQMovie_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQMovie_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQMovie_CustomEvent(this, event); };
	void deleteLater() { callbackQMovie_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQMovie_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQMovie_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQMovie_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQMovie_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQMovie_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

struct QtGui_PackedList QMovie_QMovie_SupportedFormats()
{
	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QMovie::supportedFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QMovie_NewQMovie2(void* device, void* format, void* parent)
{
	return new MyQMovie(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format), static_cast<QObject*>(parent));
}

void* QMovie_NewQMovie(void* parent)
{
	return new MyQMovie(static_cast<QObject*>(parent));
}

void* QMovie_NewQMovie3(char* fileName, void* format, void* parent)
{
	return new MyQMovie(QString(fileName), *static_cast<QByteArray*>(format), static_cast<QObject*>(parent));
}

void* QMovie_ScaledSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QMovie*>(ptr)->scaledSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QMovie_JumpToFrame(void* ptr, int frameNumber)
{
	return static_cast<QMovie*>(ptr)->jumpToFrame(frameNumber);
}

char QMovie_JumpToNextFrame(void* ptr)
{
	bool returnArg;
	QMetaObject::invokeMethod(static_cast<QMovie*>(ptr), "jumpToNextFrame", Q_RETURN_ARG(bool, returnArg));
	return returnArg;
}

char QMovie_JumpToNextFrameDefault(void* ptr)
{
		return static_cast<QMovie*>(ptr)->QMovie::jumpToNextFrame();
}

void QMovie_ConnectError(void* ptr)
{
	QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(QImageReader::ImageReaderError)>(&QMovie::error), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(QImageReader::ImageReaderError)>(&MyQMovie::Signal_Error));
}

void QMovie_DisconnectError(void* ptr)
{
	QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(QImageReader::ImageReaderError)>(&QMovie::error), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(QImageReader::ImageReaderError)>(&MyQMovie::Signal_Error));
}

void QMovie_Error(void* ptr, long long error)
{
	static_cast<QMovie*>(ptr)->error(static_cast<QImageReader::ImageReaderError>(error));
}

void QMovie_ConnectFinished(void* ptr)
{
	QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)()>(&QMovie::finished), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)()>(&MyQMovie::Signal_Finished));
}

void QMovie_DisconnectFinished(void* ptr)
{
	QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)()>(&QMovie::finished), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)()>(&MyQMovie::Signal_Finished));
}

void QMovie_Finished(void* ptr)
{
	static_cast<QMovie*>(ptr)->finished();
}

void QMovie_ConnectFrameChanged(void* ptr)
{
	QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(int)>(&QMovie::frameChanged), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(int)>(&MyQMovie::Signal_FrameChanged));
}

void QMovie_DisconnectFrameChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(int)>(&QMovie::frameChanged), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(int)>(&MyQMovie::Signal_FrameChanged));
}

void QMovie_FrameChanged(void* ptr, int frameNumber)
{
	static_cast<QMovie*>(ptr)->frameChanged(frameNumber);
}

void QMovie_ConnectResized(void* ptr)
{
	QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(const QSize &)>(&QMovie::resized), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(const QSize &)>(&MyQMovie::Signal_Resized));
}

void QMovie_DisconnectResized(void* ptr)
{
	QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(const QSize &)>(&QMovie::resized), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(const QSize &)>(&MyQMovie::Signal_Resized));
}

void QMovie_Resized(void* ptr, void* size)
{
	static_cast<QMovie*>(ptr)->resized(*static_cast<QSize*>(size));
}

void QMovie_SetBackgroundColor(void* ptr, void* color)
{
	static_cast<QMovie*>(ptr)->setBackgroundColor(*static_cast<QColor*>(color));
}

void QMovie_SetCacheMode(void* ptr, long long mode)
{
	static_cast<QMovie*>(ptr)->setCacheMode(static_cast<QMovie::CacheMode>(mode));
}

void QMovie_SetDevice(void* ptr, void* device)
{
	static_cast<QMovie*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}

void QMovie_SetFileName(void* ptr, char* fileName)
{
	static_cast<QMovie*>(ptr)->setFileName(QString(fileName));
}

void QMovie_SetFormat(void* ptr, void* format)
{
	static_cast<QMovie*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}

void QMovie_SetPaused(void* ptr, char paused)
{
	QMetaObject::invokeMethod(static_cast<QMovie*>(ptr), "setPaused", Q_ARG(bool, paused != 0));
}

void QMovie_SetPausedDefault(void* ptr, char paused)
{
		static_cast<QMovie*>(ptr)->QMovie::setPaused(paused != 0);
}

void QMovie_SetScaledSize(void* ptr, void* size)
{
	static_cast<QMovie*>(ptr)->setScaledSize(*static_cast<QSize*>(size));
}

void QMovie_SetSpeed(void* ptr, int percentSpeed)
{
	QMetaObject::invokeMethod(static_cast<QMovie*>(ptr), "setSpeed", Q_ARG(int, percentSpeed));
}

void QMovie_SetSpeedDefault(void* ptr, int percentSpeed)
{
		static_cast<QMovie*>(ptr)->QMovie::setSpeed(percentSpeed);
}

void QMovie_Start(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMovie*>(ptr), "start");
}

void QMovie_StartDefault(void* ptr)
{
		static_cast<QMovie*>(ptr)->QMovie::start();
}

void QMovie_ConnectStarted(void* ptr)
{
	QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)()>(&QMovie::started), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)()>(&MyQMovie::Signal_Started));
}

void QMovie_DisconnectStarted(void* ptr)
{
	QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)()>(&QMovie::started), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)()>(&MyQMovie::Signal_Started));
}

void QMovie_Started(void* ptr)
{
	static_cast<QMovie*>(ptr)->started();
}

void QMovie_ConnectStateChanged(void* ptr)
{
	QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(QMovie::MovieState)>(&QMovie::stateChanged), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(QMovie::MovieState)>(&MyQMovie::Signal_StateChanged));
}

void QMovie_DisconnectStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(QMovie::MovieState)>(&QMovie::stateChanged), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(QMovie::MovieState)>(&MyQMovie::Signal_StateChanged));
}

void QMovie_StateChanged(void* ptr, long long state)
{
	static_cast<QMovie*>(ptr)->stateChanged(static_cast<QMovie::MovieState>(state));
}

void QMovie_Stop(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QMovie*>(ptr), "stop");
}

void QMovie_StopDefault(void* ptr)
{
		static_cast<QMovie*>(ptr)->QMovie::stop();
}

void QMovie_ConnectUpdated(void* ptr)
{
	QObject::connect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(const QRect &)>(&QMovie::updated), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(const QRect &)>(&MyQMovie::Signal_Updated));
}

void QMovie_DisconnectUpdated(void* ptr)
{
	QObject::disconnect(static_cast<QMovie*>(ptr), static_cast<void (QMovie::*)(const QRect &)>(&QMovie::updated), static_cast<MyQMovie*>(ptr), static_cast<void (MyQMovie::*)(const QRect &)>(&MyQMovie::Signal_Updated));
}

void QMovie_Updated(void* ptr, void* rect)
{
	static_cast<QMovie*>(ptr)->updated(*static_cast<QRect*>(rect));
}

void QMovie_DestroyQMovie(void* ptr)
{
	static_cast<QMovie*>(ptr)->~QMovie();
}

long long QMovie_CacheMode(void* ptr)
{
	return static_cast<QMovie*>(ptr)->cacheMode();
}

long long QMovie_State(void* ptr)
{
	return static_cast<QMovie*>(ptr)->state();
}

void* QMovie_Format(void* ptr)
{
	return new QByteArray(static_cast<QMovie*>(ptr)->format());
}

void* QMovie_BackgroundColor(void* ptr)
{
	return new QColor(static_cast<QMovie*>(ptr)->backgroundColor());
}

void* QMovie_Device(void* ptr)
{
	return static_cast<QMovie*>(ptr)->device();
}

void* QMovie_CurrentImage(void* ptr)
{
	return new QImage(static_cast<QMovie*>(ptr)->currentImage());
}

void* QMovie_CurrentPixmap(void* ptr)
{
	return new QPixmap(static_cast<QMovie*>(ptr)->currentPixmap());
}

void* QMovie_FrameRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QMovie*>(ptr)->frameRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QMovie_FileName(void* ptr)
{
	return ({ QByteArray t73bc7e = static_cast<QMovie*>(ptr)->fileName().toUtf8(); QtGui_PackedString { const_cast<char*>(t73bc7e.prepend("WHITESPACE").constData()+10), t73bc7e.size()-10 }; });
}

char QMovie_IsValid(void* ptr)
{
	return static_cast<QMovie*>(ptr)->isValid();
}

int QMovie_CurrentFrameNumber(void* ptr)
{
	return static_cast<QMovie*>(ptr)->currentFrameNumber();
}

int QMovie_FrameCount(void* ptr)
{
	return static_cast<QMovie*>(ptr)->frameCount();
}

int QMovie_LoopCount(void* ptr)
{
	return static_cast<QMovie*>(ptr)->loopCount();
}

int QMovie_NextFrameDelay(void* ptr)
{
	return static_cast<QMovie*>(ptr)->nextFrameDelay();
}

int QMovie_Speed(void* ptr)
{
	return static_cast<QMovie*>(ptr)->speed();
}

void* QMovie___supportedFormats_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QMovie___supportedFormats_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QMovie___supportedFormats_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QMovie___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QMovie___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QMovie___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QMovie___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMovie___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMovie___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QMovie___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMovie___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMovie___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QMovie___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QMovie___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMovie___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QMovie___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QMovie___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QMovie___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QMovie_EventDefault(void* ptr, void* e)
{
		return static_cast<QMovie*>(ptr)->QMovie::event(static_cast<QEvent*>(e));
}

char QMovie_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QMovie*>(ptr)->QMovie::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QMovie*>(ptr)->QMovie::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QMovie*>(ptr)->QMovie::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QMovie*>(ptr)->QMovie::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QMovie*>(ptr)->QMovie::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QMovie_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QMovie*>(ptr)->QMovie::childEvent(static_cast<QChildEvent*>(event));
}

void QMovie_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QMovie*>(ptr)->QMovie::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMovie_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QMovie*>(ptr)->QMovie::customEvent(static_cast<QEvent*>(event));
}

void QMovie_DeleteLaterDefault(void* ptr)
{
		static_cast<QMovie*>(ptr)->QMovie::deleteLater();
}

void QMovie_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QMovie*>(ptr)->QMovie::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QMovie_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QMovie*>(ptr)->QMovie::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QMovie_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QMovie*>(ptr)->QMovie::metaObject());
}

class MyQNativeGestureEvent: public QNativeGestureEvent
{
public:
	MyQNativeGestureEvent(Qt::NativeGestureType type, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos, qreal realValue, ulong sequenceId, quint64 intValue) : QNativeGestureEvent(type, localPos, windowPos, screenPos, realValue, sequenceId, intValue) {};
};

void* QNativeGestureEvent_NewQNativeGestureEvent(long long ty, void* localPos, void* windowPos, void* screenPos, double realValue, unsigned long sequenceId, unsigned long long intValue)
{
	return new MyQNativeGestureEvent(static_cast<Qt::NativeGestureType>(ty), *static_cast<QPointF*>(localPos), *static_cast<QPointF*>(windowPos), *static_cast<QPointF*>(screenPos), realValue, sequenceId, intValue);
}

long long QNativeGestureEvent_GestureType(void* ptr)
{
	return static_cast<QNativeGestureEvent*>(ptr)->gestureType();
}

void* QNativeGestureEvent_GlobalPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QNativeGestureEvent*>(ptr)->globalPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QNativeGestureEvent_Pos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QNativeGestureEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QNativeGestureEvent_LocalPos(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QNativeGestureEvent*>(ptr)->localPos());
}

void* QNativeGestureEvent_ScreenPos(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QNativeGestureEvent*>(ptr)->screenPos());
}

void* QNativeGestureEvent_WindowPos(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QNativeGestureEvent*>(ptr)->windowPos());
}

double QNativeGestureEvent_Value(void* ptr)
{
	return static_cast<QNativeGestureEvent*>(ptr)->value();
}

long long QNativeGestureEvent_MGestureType(void* ptr)
{
	return static_cast<QNativeGestureEvent*>(ptr)->mGestureType;
}

void QNativeGestureEvent_SetMGestureType(void* ptr, long long vqt)
{
	static_cast<QNativeGestureEvent*>(ptr)->mGestureType = static_cast<Qt::NativeGestureType>(vqt);
}

unsigned long long QNativeGestureEvent_MIntValue(void* ptr)
{
	return static_cast<QNativeGestureEvent*>(ptr)->mIntValue;
}

void QNativeGestureEvent_SetMIntValue(void* ptr, unsigned long long vqu)
{
	static_cast<QNativeGestureEvent*>(ptr)->mIntValue = vqu;
}

void* QNativeGestureEvent_MLocalPos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QNativeGestureEvent*>(ptr)->mLocalPos; new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QNativeGestureEvent_SetMLocalPos(void* ptr, void* vqp)
{
	static_cast<QNativeGestureEvent*>(ptr)->mLocalPos = *static_cast<QPointF*>(vqp);
}

double QNativeGestureEvent_MRealValue(void* ptr)
{
	return static_cast<QNativeGestureEvent*>(ptr)->mRealValue;
}

void QNativeGestureEvent_SetMRealValue(void* ptr, double vqr)
{
	static_cast<QNativeGestureEvent*>(ptr)->mRealValue = vqr;
}

void* QNativeGestureEvent_MScreenPos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QNativeGestureEvent*>(ptr)->mScreenPos; new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QNativeGestureEvent_SetMScreenPos(void* ptr, void* vqp)
{
	static_cast<QNativeGestureEvent*>(ptr)->mScreenPos = *static_cast<QPointF*>(vqp);
}

unsigned long QNativeGestureEvent_MSequenceId(void* ptr)
{
	return static_cast<QNativeGestureEvent*>(ptr)->mSequenceId;
}

void QNativeGestureEvent_SetMSequenceId(void* ptr, unsigned long vul)
{
	static_cast<QNativeGestureEvent*>(ptr)->mSequenceId = vul;
}

void* QNativeGestureEvent_MWindowPos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QNativeGestureEvent*>(ptr)->mWindowPos; new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QNativeGestureEvent_SetMWindowPos(void* ptr, void* vqp)
{
	static_cast<QNativeGestureEvent*>(ptr)->mWindowPos = *static_cast<QPointF*>(vqp);
}

class MyQOffscreenSurface: public QOffscreenSurface
{
public:
	MyQOffscreenSurface(QScreen *targetScreen) : QOffscreenSurface(targetScreen) {};
	void Signal_ScreenChanged(QScreen * screen) { callbackQOffscreenSurface_ScreenChanged(this, screen); };
	 ~MyQOffscreenSurface() { callbackQOffscreenSurface_DestroyQOffscreenSurface(this); };
	QSize size() const { return *static_cast<QSize*>(callbackQOffscreenSurface_Size(const_cast<void*>(static_cast<const void*>(this)))); };
	QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQOffscreenSurface_Format(const_cast<void*>(static_cast<const void*>(this)))); };
	SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQOffscreenSurface_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
	bool event(QEvent * e) { return callbackQOffscreenSurface_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQOffscreenSurface_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQOffscreenSurface_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQOffscreenSurface_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQOffscreenSurface_CustomEvent(this, event); };
	void deleteLater() { callbackQOffscreenSurface_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQOffscreenSurface_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQOffscreenSurface_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQOffscreenSurface_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQOffscreenSurface_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQOffscreenSurface_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QOffscreenSurface_NewQOffscreenSurface(void* targetScreen)
{
	return new MyQOffscreenSurface(static_cast<QScreen*>(targetScreen));
}

void QOffscreenSurface_Create(void* ptr)
{
		static_cast<QOffscreenSurface*>(ptr)->create();
}

void QOffscreenSurface_Destroy(void* ptr)
{
		static_cast<QOffscreenSurface*>(ptr)->destroy();
}

void QOffscreenSurface_ConnectScreenChanged(void* ptr)
{
	QObject::connect(static_cast<QOffscreenSurface*>(ptr), static_cast<void (QOffscreenSurface::*)(QScreen *)>(&QOffscreenSurface::screenChanged), static_cast<MyQOffscreenSurface*>(ptr), static_cast<void (MyQOffscreenSurface::*)(QScreen *)>(&MyQOffscreenSurface::Signal_ScreenChanged));
}

void QOffscreenSurface_DisconnectScreenChanged(void* ptr)
{
	QObject::disconnect(static_cast<QOffscreenSurface*>(ptr), static_cast<void (QOffscreenSurface::*)(QScreen *)>(&QOffscreenSurface::screenChanged), static_cast<MyQOffscreenSurface*>(ptr), static_cast<void (MyQOffscreenSurface::*)(QScreen *)>(&MyQOffscreenSurface::Signal_ScreenChanged));
}

void QOffscreenSurface_ScreenChanged(void* ptr, void* screen)
{
		static_cast<QOffscreenSurface*>(ptr)->screenChanged(static_cast<QScreen*>(screen));
}

void QOffscreenSurface_SetFormat(void* ptr, void* format)
{
		static_cast<QOffscreenSurface*>(ptr)->setFormat(*static_cast<QSurfaceFormat*>(format));
}

void QOffscreenSurface_SetScreen(void* ptr, void* newScreen)
{
		static_cast<QOffscreenSurface*>(ptr)->setScreen(static_cast<QScreen*>(newScreen));
}

void QOffscreenSurface_DestroyQOffscreenSurface(void* ptr)
{
	static_cast<QOffscreenSurface*>(ptr)->~QOffscreenSurface();
}

void QOffscreenSurface_DestroyQOffscreenSurfaceDefault(void* ptr)
{

}

void* QOffscreenSurface_Screen(void* ptr)
{
		return static_cast<QOffscreenSurface*>(ptr)->screen();
}

void* QOffscreenSurface_Size(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QOffscreenSurface*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QOffscreenSurface_SizeDefault(void* ptr)
{
		return ({ QSize tmpValue = static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::size(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QOffscreenSurface_Format(void* ptr)
{
		return new QSurfaceFormat(static_cast<QOffscreenSurface*>(ptr)->format());
}

void* QOffscreenSurface_FormatDefault(void* ptr)
{
		return new QSurfaceFormat(static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::format());
}

void* QOffscreenSurface_RequestedFormat(void* ptr)
{
		return new QSurfaceFormat(static_cast<QOffscreenSurface*>(ptr)->requestedFormat());
}

long long QOffscreenSurface_SurfaceType(void* ptr)
{
		return static_cast<QOffscreenSurface*>(ptr)->surfaceType();
}

long long QOffscreenSurface_SurfaceTypeDefault(void* ptr)
{
		return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::surfaceType();
}

char QOffscreenSurface_IsValid(void* ptr)
{
		return static_cast<QOffscreenSurface*>(ptr)->isValid();
}

void* QOffscreenSurface___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QOffscreenSurface___dynamicPropertyNames_setList(void* ptr, void* i)
{
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QOffscreenSurface___dynamicPropertyNames_newList(void* ptr)
{
		return new QList<QByteArray>;
}

void* QOffscreenSurface___findChildren_atList2(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QOffscreenSurface___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QOffscreenSurface___findChildren_newList2(void* ptr)
{
		return new QList<QObject*>;
}

void* QOffscreenSurface___findChildren_atList3(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QOffscreenSurface___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QOffscreenSurface___findChildren_newList3(void* ptr)
{
		return new QList<QObject*>;
}

void* QOffscreenSurface___findChildren_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QOffscreenSurface___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QOffscreenSurface___findChildren_newList(void* ptr)
{
		return new QList<QObject*>;
}

void* QOffscreenSurface___children_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QOffscreenSurface___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QOffscreenSurface___children_newList(void* ptr)
{
		return new QList<QObject *>;
}

char QOffscreenSurface_Event(void* ptr, void* e)
{
		return static_cast<QOffscreenSurface*>(ptr)->event(static_cast<QEvent*>(e));
}

char QOffscreenSurface_EventDefault(void* ptr, void* e)
{
		return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::event(static_cast<QEvent*>(e));
}

char QOffscreenSurface_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QOffscreenSurface*>(ptr)->eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QOffscreenSurface*>(ptr)->eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QOffscreenSurface*>(ptr)->eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QOffscreenSurface*>(ptr)->eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QOffscreenSurface*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QOffscreenSurface_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QOffscreenSurface_ChildEvent(void* ptr, void* event)
{
		static_cast<QOffscreenSurface*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QOffscreenSurface_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::childEvent(static_cast<QChildEvent*>(event));
}

void QOffscreenSurface_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QOffscreenSurface*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QOffscreenSurface_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QOffscreenSurface_CustomEvent(void* ptr, void* event)
{
		static_cast<QOffscreenSurface*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QOffscreenSurface_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::customEvent(static_cast<QEvent*>(event));
}

void QOffscreenSurface_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QOffscreenSurface*>(ptr), "deleteLater");
}

void QOffscreenSurface_DeleteLaterDefault(void* ptr)
{
		static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::deleteLater();
}

void QOffscreenSurface_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QOffscreenSurface*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QOffscreenSurface_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QOffscreenSurface_TimerEvent(void* ptr, void* event)
{
		static_cast<QOffscreenSurface*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QOffscreenSurface_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QOffscreenSurface_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QOffscreenSurface*>(ptr)->metaObject());
}

void* QOffscreenSurface_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QOffscreenSurface*>(ptr)->QOffscreenSurface::metaObject());
}

void* QPageLayout_NewQPageLayout()
{
	return new QPageLayout();
}

void* QPageLayout_NewQPageLayout3(void* other)
{
	return new QPageLayout(*static_cast<QPageLayout*>(other));
}

void* QPageLayout_NewQPageLayout2(void* pageSize, long long orientation, void* margins, long long units, void* minMargins)
{
	return new QPageLayout(*static_cast<QPageSize*>(pageSize), static_cast<QPageLayout::Orientation>(orientation), *static_cast<QMarginsF*>(margins), static_cast<QPageLayout::Unit>(units), *static_cast<QMarginsF*>(minMargins));
}

char QPageLayout_SetBottomMargin(void* ptr, double bottomMargin)
{
	return static_cast<QPageLayout*>(ptr)->setBottomMargin(bottomMargin);
}

char QPageLayout_SetLeftMargin(void* ptr, double leftMargin)
{
	return static_cast<QPageLayout*>(ptr)->setLeftMargin(leftMargin);
}

char QPageLayout_SetMargins(void* ptr, void* margins)
{
	return static_cast<QPageLayout*>(ptr)->setMargins(*static_cast<QMarginsF*>(margins));
}

char QPageLayout_SetRightMargin(void* ptr, double rightMargin)
{
	return static_cast<QPageLayout*>(ptr)->setRightMargin(rightMargin);
}

char QPageLayout_SetTopMargin(void* ptr, double topMargin)
{
	return static_cast<QPageLayout*>(ptr)->setTopMargin(topMargin);
}

void QPageLayout_SetMinimumMargins(void* ptr, void* minMargins)
{
	static_cast<QPageLayout*>(ptr)->setMinimumMargins(*static_cast<QMarginsF*>(minMargins));
}

void QPageLayout_SetMode(void* ptr, long long mode)
{
	static_cast<QPageLayout*>(ptr)->setMode(static_cast<QPageLayout::Mode>(mode));
}

void QPageLayout_SetOrientation(void* ptr, long long orientation)
{
	static_cast<QPageLayout*>(ptr)->setOrientation(static_cast<QPageLayout::Orientation>(orientation));
}

void QPageLayout_SetPageSize(void* ptr, void* pageSize, void* minMargins)
{
	static_cast<QPageLayout*>(ptr)->setPageSize(*static_cast<QPageSize*>(pageSize), *static_cast<QMarginsF*>(minMargins));
}

void QPageLayout_SetUnits(void* ptr, long long units)
{
	static_cast<QPageLayout*>(ptr)->setUnits(static_cast<QPageLayout::Unit>(units));
}

void QPageLayout_Swap(void* ptr, void* other)
{
	static_cast<QPageLayout*>(ptr)->swap(*static_cast<QPageLayout*>(other));
}

void QPageLayout_DestroyQPageLayout(void* ptr)
{
	static_cast<QPageLayout*>(ptr)->~QPageLayout();
}

long long QPageLayout_Mode(void* ptr)
{
	return static_cast<QPageLayout*>(ptr)->mode();
}

long long QPageLayout_Orientation(void* ptr)
{
	return static_cast<QPageLayout*>(ptr)->orientation();
}

void* QPageLayout_MarginsPixels(void* ptr, int resolution)
{
	return ({ QMargins tmpValue = static_cast<QPageLayout*>(ptr)->marginsPixels(resolution); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}

void* QPageLayout_MarginsPoints(void* ptr)
{
	return ({ QMargins tmpValue = static_cast<QPageLayout*>(ptr)->marginsPoints(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}

void* QPageLayout_Margins(void* ptr)
{
	return ({ QMarginsF tmpValue = static_cast<QPageLayout*>(ptr)->margins(); new QMarginsF(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}

void* QPageLayout_Margins2(void* ptr, long long units)
{
	return ({ QMarginsF tmpValue = static_cast<QPageLayout*>(ptr)->margins(static_cast<QPageLayout::Unit>(units)); new QMarginsF(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}

void* QPageLayout_MaximumMargins(void* ptr)
{
	return ({ QMarginsF tmpValue = static_cast<QPageLayout*>(ptr)->maximumMargins(); new QMarginsF(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}

void* QPageLayout_MinimumMargins(void* ptr)
{
	return ({ QMarginsF tmpValue = static_cast<QPageLayout*>(ptr)->minimumMargins(); new QMarginsF(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}

void* QPageLayout_PageSize(void* ptr)
{
	return new QPageSize(static_cast<QPageLayout*>(ptr)->pageSize());
}

void* QPageLayout_FullRectPixels(void* ptr, int resolution)
{
	return ({ QRect tmpValue = static_cast<QPageLayout*>(ptr)->fullRectPixels(resolution); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPageLayout_FullRectPoints(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPageLayout*>(ptr)->fullRectPoints(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPageLayout_PaintRectPixels(void* ptr, int resolution)
{
	return ({ QRect tmpValue = static_cast<QPageLayout*>(ptr)->paintRectPixels(resolution); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPageLayout_PaintRectPoints(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPageLayout*>(ptr)->paintRectPoints(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPageLayout_FullRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QPageLayout*>(ptr)->fullRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPageLayout_FullRect2(void* ptr, long long units)
{
	return ({ QRectF tmpValue = static_cast<QPageLayout*>(ptr)->fullRect(static_cast<QPageLayout::Unit>(units)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPageLayout_PaintRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QPageLayout*>(ptr)->paintRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPageLayout_PaintRect2(void* ptr, long long units)
{
	return ({ QRectF tmpValue = static_cast<QPageLayout*>(ptr)->paintRect(static_cast<QPageLayout::Unit>(units)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

long long QPageLayout_Units(void* ptr)
{
	return static_cast<QPageLayout*>(ptr)->units();
}

char QPageLayout_IsEquivalentTo(void* ptr, void* other)
{
	return static_cast<QPageLayout*>(ptr)->isEquivalentTo(*static_cast<QPageLayout*>(other));
}

char QPageLayout_IsValid(void* ptr)
{
	return static_cast<QPageLayout*>(ptr)->isValid();
}

long long QPageSize_QPageSize_Id2(void* pointSize, long long matchPolicy)
{
	return QPageSize::id(*static_cast<QSize*>(pointSize), static_cast<QPageSize::SizeMatchPolicy>(matchPolicy));
}

long long QPageSize_QPageSize_Id3(void* size, long long units, long long matchPolicy)
{
	return QPageSize::id(*static_cast<QSizeF*>(size), static_cast<QPageSize::Unit>(units), static_cast<QPageSize::SizeMatchPolicy>(matchPolicy));
}

long long QPageSize_QPageSize_Id4(int windowsId)
{
	return QPageSize::id(windowsId);
}

void* QPageSize_NewQPageSize()
{
	return new QPageSize();
}

void* QPageSize_NewQPageSize2(long long pageSize)
{
	return new QPageSize(static_cast<QPageSize::PageSizeId>(pageSize));
}

void* QPageSize_NewQPageSize5(void* other)
{
	return new QPageSize(*static_cast<QPageSize*>(other));
}

void* QPageSize_NewQPageSize3(void* pointSize, char* name, long long matchPolicy)
{
	return new QPageSize(*static_cast<QSize*>(pointSize), QString(name), static_cast<QPageSize::SizeMatchPolicy>(matchPolicy));
}

void* QPageSize_NewQPageSize4(void* size, long long units, char* name, long long matchPolicy)
{
	return new QPageSize(*static_cast<QSizeF*>(size), static_cast<QPageSize::Unit>(units), QString(name), static_cast<QPageSize::SizeMatchPolicy>(matchPolicy));
}

void* QPageSize_QPageSize_SizePixels2(long long pageSizeId, int resolution)
{
	return ({ QSize tmpValue = QPageSize::sizePixels(static_cast<QPageSize::PageSizeId>(pageSizeId), resolution); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QPageSize_QPageSize_SizePoints2(long long pageSizeId)
{
	return ({ QSize tmpValue = QPageSize::sizePoints(static_cast<QPageSize::PageSizeId>(pageSizeId)); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QPageSize_QPageSize_DefinitionSize2(long long pageSizeId)
{
	return ({ QSizeF tmpValue = QPageSize::definitionSize(static_cast<QPageSize::PageSizeId>(pageSizeId)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QPageSize_QPageSize_Size2(long long pageSizeId, long long units)
{
	return ({ QSizeF tmpValue = QPageSize::size(static_cast<QPageSize::PageSizeId>(pageSizeId), static_cast<QPageSize::Unit>(units)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QPageSize_QPageSize_Key2(long long pageSizeId)
{
	return ({ QByteArray tba9d4f = QPageSize::key(static_cast<QPageSize::PageSizeId>(pageSizeId)).toUtf8(); QtGui_PackedString { const_cast<char*>(tba9d4f.prepend("WHITESPACE").constData()+10), tba9d4f.size()-10 }; });
}

struct QtGui_PackedString QPageSize_QPageSize_Name2(long long pageSizeId)
{
	return ({ QByteArray t8d3c9f = QPageSize::name(static_cast<QPageSize::PageSizeId>(pageSizeId)).toUtf8(); QtGui_PackedString { const_cast<char*>(t8d3c9f.prepend("WHITESPACE").constData()+10), t8d3c9f.size()-10 }; });
}

long long QPageSize_QPageSize_DefinitionUnits2(long long pageSizeId)
{
	return QPageSize::definitionUnits(static_cast<QPageSize::PageSizeId>(pageSizeId));
}

int QPageSize_QPageSize_WindowsId2(long long pageSizeId)
{
	return QPageSize::windowsId(static_cast<QPageSize::PageSizeId>(pageSizeId));
}

void QPageSize_Swap(void* ptr, void* other)
{
	static_cast<QPageSize*>(ptr)->swap(*static_cast<QPageSize*>(other));
}

void QPageSize_DestroyQPageSize(void* ptr)
{
	static_cast<QPageSize*>(ptr)->~QPageSize();
}

long long QPageSize_Id(void* ptr)
{
	return static_cast<QPageSize*>(ptr)->id();
}

void* QPageSize_RectPixels(void* ptr, int resolution)
{
	return ({ QRect tmpValue = static_cast<QPageSize*>(ptr)->rectPixels(resolution); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPageSize_RectPoints(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPageSize*>(ptr)->rectPoints(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPageSize_Rect(void* ptr, long long units)
{
	return ({ QRectF tmpValue = static_cast<QPageSize*>(ptr)->rect(static_cast<QPageSize::Unit>(units)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPageSize_SizePixels(void* ptr, int resolution)
{
	return ({ QSize tmpValue = static_cast<QPageSize*>(ptr)->sizePixels(resolution); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QPageSize_SizePoints(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPageSize*>(ptr)->sizePoints(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QPageSize_DefinitionSize(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QPageSize*>(ptr)->definitionSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QPageSize_Size(void* ptr, long long units)
{
	return ({ QSizeF tmpValue = static_cast<QPageSize*>(ptr)->size(static_cast<QPageSize::Unit>(units)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QPageSize_Key(void* ptr)
{
	return ({ QByteArray t01da2c = static_cast<QPageSize*>(ptr)->key().toUtf8(); QtGui_PackedString { const_cast<char*>(t01da2c.prepend("WHITESPACE").constData()+10), t01da2c.size()-10 }; });
}

struct QtGui_PackedString QPageSize_Name(void* ptr)
{
	return ({ QByteArray t2620ab = static_cast<QPageSize*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(t2620ab.prepend("WHITESPACE").constData()+10), t2620ab.size()-10 }; });
}

long long QPageSize_DefinitionUnits(void* ptr)
{
	return static_cast<QPageSize*>(ptr)->definitionUnits();
}

char QPageSize_IsEquivalentTo(void* ptr, void* other)
{
	return static_cast<QPageSize*>(ptr)->isEquivalentTo(*static_cast<QPageSize*>(other));
}

char QPageSize_IsValid(void* ptr)
{
	return static_cast<QPageSize*>(ptr)->isValid();
}

int QPageSize_WindowsId(void* ptr)
{
	return static_cast<QPageSize*>(ptr)->windowsId();
}

class MyQPagedPaintDevice: public QPagedPaintDevice
{
public:
	MyQPagedPaintDevice() : QPagedPaintDevice() {};
	bool newPage() { return callbackQPagedPaintDevice_NewPage(this) != 0; };
	void setPageSize(QPagedPaintDevice::PageSize size) { callbackQPagedPaintDevice_SetPageSize2(this, size); };
	void setPageSizeMM(const QSizeF & size) { callbackQPagedPaintDevice_SetPageSizeMM(this, const_cast<QSizeF*>(&size)); };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPagedPaintDevice_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};

void* QPagedPaintDevice_NewQPagedPaintDevice()
{
	return new MyQPagedPaintDevice();
}

char QPagedPaintDevice_NewPage(void* ptr)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->newPage();
	} else {
		return static_cast<QPagedPaintDevice*>(ptr)->newPage();
	}
}

char QPagedPaintDevice_SetPageLayout(void* ptr, void* newPageLayout)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->setPageLayout(*static_cast<QPageLayout*>(newPageLayout));
	} else {
		return static_cast<QPagedPaintDevice*>(ptr)->setPageLayout(*static_cast<QPageLayout*>(newPageLayout));
	}
}

char QPagedPaintDevice_SetPageMargins(void* ptr, void* margins)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->setPageMargins(*static_cast<QMarginsF*>(margins));
	} else {
		return static_cast<QPagedPaintDevice*>(ptr)->setPageMargins(*static_cast<QMarginsF*>(margins));
	}
}

char QPagedPaintDevice_SetPageMargins2(void* ptr, void* margins, long long units)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->setPageMargins(*static_cast<QMarginsF*>(margins), static_cast<QPageLayout::Unit>(units));
	} else {
		return static_cast<QPagedPaintDevice*>(ptr)->setPageMargins(*static_cast<QMarginsF*>(margins), static_cast<QPageLayout::Unit>(units));
	}
}

char QPagedPaintDevice_SetPageOrientation(void* ptr, long long orientation)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->setPageOrientation(static_cast<QPageLayout::Orientation>(orientation));
	} else {
		return static_cast<QPagedPaintDevice*>(ptr)->setPageOrientation(static_cast<QPageLayout::Orientation>(orientation));
	}
}

char QPagedPaintDevice_SetPageSize(void* ptr, void* pageSize)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->setPageSize(*static_cast<QPageSize*>(pageSize));
	} else {
		return static_cast<QPagedPaintDevice*>(ptr)->setPageSize(*static_cast<QPageSize*>(pageSize));
	}
}

void QPagedPaintDevice_SetPageSize2(void* ptr, long long size)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		static_cast<QPdfWriter*>(ptr)->setPageSize(static_cast<QPagedPaintDevice::PageSize>(size));
	} else {
		static_cast<QPagedPaintDevice*>(ptr)->setPageSize(static_cast<QPagedPaintDevice::PageSize>(size));
	}
}

void QPagedPaintDevice_SetPageSize2Default(void* ptr, long long size)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		static_cast<QPdfWriter*>(ptr)->QPdfWriter::setPageSize(static_cast<QPagedPaintDevice::PageSize>(size));
	} else {
		static_cast<QPagedPaintDevice*>(ptr)->QPagedPaintDevice::setPageSize(static_cast<QPagedPaintDevice::PageSize>(size));
	}
}

void QPagedPaintDevice_SetPageSizeMM(void* ptr, void* size)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		static_cast<QPdfWriter*>(ptr)->setPageSizeMM(*static_cast<QSizeF*>(size));
	} else {
		static_cast<QPagedPaintDevice*>(ptr)->setPageSizeMM(*static_cast<QSizeF*>(size));
	}
}

void QPagedPaintDevice_SetPageSizeMMDefault(void* ptr, void* size)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		static_cast<QPdfWriter*>(ptr)->QPdfWriter::setPageSizeMM(*static_cast<QSizeF*>(size));
	} else {
		static_cast<QPagedPaintDevice*>(ptr)->QPagedPaintDevice::setPageSizeMM(*static_cast<QSizeF*>(size));
	}
}

void QPagedPaintDevice_DestroyQPagedPaintDevice(void* ptr)
{
	static_cast<QPagedPaintDevice*>(ptr)->~QPagedPaintDevice();
}

long long QPagedPaintDevice_PageSize(void* ptr)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->pageSize();
	} else {
		return static_cast<QPagedPaintDevice*>(ptr)->pageSize();
	}
}

void* QPagedPaintDevice_PageLayout(void* ptr)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return new QPageLayout(static_cast<QPdfWriter*>(ptr)->pageLayout());
	} else {
		return new QPageLayout(static_cast<QPagedPaintDevice*>(ptr)->pageLayout());
	}
}

void* QPagedPaintDevice_PageSizeMM(void* ptr)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return ({ QSizeF tmpValue = static_cast<QPdfWriter*>(ptr)->pageSizeMM(); new QSizeF(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSizeF tmpValue = static_cast<QPagedPaintDevice*>(ptr)->pageSizeMM(); new QSizeF(tmpValue.width(), tmpValue.height()); });
	}
}

void* QPagedPaintDevice_PaintEngine(void* ptr)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->paintEngine();
	} else {
	
	}
}

void* QPagedPaintDevice_PaintEngineDefault(void* ptr)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->QPdfWriter::paintEngine();
	} else {
	
	}
}

class MyQPaintDevice: public QPaintDevice
{
public:
	MyQPaintDevice() : QPaintDevice() {};
	 ~MyQPaintDevice() { callbackQPaintDevice_DestroyQPaintDevice(this); };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPaintDevice_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};

void* QPaintDevice_NewQPaintDevice()
{
	return new MyQPaintDevice();
}

void QPaintDevice_DestroyQPaintDevice(void* ptr)
{
	static_cast<QPaintDevice*>(ptr)->~QPaintDevice();
}

void QPaintDevice_DestroyQPaintDeviceDefault(void* ptr)
{

}

void* QPaintDevice_PaintEngine(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->paintEngine();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->paintEngine();
	} else {
		return static_cast<QPaintDevice*>(ptr)->paintEngine();
	}
}

char QPaintDevice_PaintingActive(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->paintingActive();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->paintingActive();
	} else {
		return static_cast<QPaintDevice*>(ptr)->paintingActive();
	}
}

int QPaintDevice_ColorCount(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->colorCount();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->colorCount();
	} else {
		return static_cast<QPaintDevice*>(ptr)->colorCount();
	}
}

int QPaintDevice_Depth(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->depth();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->depth();
	} else {
		return static_cast<QPaintDevice*>(ptr)->depth();
	}
}

int QPaintDevice_DevicePixelRatio(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->devicePixelRatio();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->devicePixelRatio();
	} else {
		return static_cast<QPaintDevice*>(ptr)->devicePixelRatio();
	}
}

int QPaintDevice_Height(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->height();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->height();
	} else {
		return static_cast<QPaintDevice*>(ptr)->height();
	}
}

int QPaintDevice_HeightMM(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->heightMM();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->heightMM();
	} else {
		return static_cast<QPaintDevice*>(ptr)->heightMM();
	}
}

int QPaintDevice_LogicalDpiX(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->logicalDpiX();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->logicalDpiX();
	} else {
		return static_cast<QPaintDevice*>(ptr)->logicalDpiX();
	}
}

int QPaintDevice_LogicalDpiY(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->logicalDpiY();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->logicalDpiY();
	} else {
		return static_cast<QPaintDevice*>(ptr)->logicalDpiY();
	}
}

int QPaintDevice_Metric(void* ptr, long long metric)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	} else {
		return static_cast<QPaintDevice*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	}
}

int QPaintDevice_MetricDefault(void* ptr, long long metric)
{
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->QPdfWriter::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	} else if (dynamic_cast<QPagedPaintDevice*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPagedPaintDevice*>(ptr)->QPagedPaintDevice::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	} else if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRasterWindow*>(ptr)->QRasterWindow::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	} else if (dynamic_cast<QBitmap*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBitmap*>(ptr)->QBitmap::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	} else if (dynamic_cast<QPixmap*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPixmap*>(ptr)->QPixmap::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	} else if (dynamic_cast<QPicture*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPicture*>(ptr)->QPicture::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	} else if (dynamic_cast<QImage*>(static_cast<QObject*>(ptr))) {
		return static_cast<QImage*>(ptr)->QImage::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	} else {
		return static_cast<QPaintDevice*>(ptr)->QPaintDevice::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
	}
}

int QPaintDevice_PhysicalDpiX(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->physicalDpiX();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->physicalDpiX();
	} else {
		return static_cast<QPaintDevice*>(ptr)->physicalDpiX();
	}
}

int QPaintDevice_PhysicalDpiY(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->physicalDpiY();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->physicalDpiY();
	} else {
		return static_cast<QPaintDevice*>(ptr)->physicalDpiY();
	}
}

int QPaintDevice_Width(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->width();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->width();
	} else {
		return static_cast<QPaintDevice*>(ptr)->width();
	}
}

int QPaintDevice_WidthMM(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->widthMM();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->widthMM();
	} else {
		return static_cast<QPaintDevice*>(ptr)->widthMM();
	}
}

double QPaintDevice_DevicePixelRatioF(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->devicePixelRatioF();
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->devicePixelRatioF();
	} else {
		return static_cast<QPaintDevice*>(ptr)->devicePixelRatioF();
	}
}

unsigned short QPaintDevice_Painters(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->painters;
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPdfWriter*>(ptr)->painters;
	} else {
		return static_cast<QPaintDevice*>(ptr)->painters;
	}
}

void QPaintDevice_SetPainters(void* ptr, unsigned short vus)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->painters = vus;
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(ptr))) {
		static_cast<QPdfWriter*>(ptr)->painters = vus;
	} else {
		static_cast<QPaintDevice*>(ptr)->painters = vus;
	}
}

class MyQPaintDeviceWindow: public QPaintDeviceWindow
{
public:
	void paintEvent(QPaintEvent * event) { callbackQPaintDeviceWindow_PaintEvent(this, event); };
	void update() { callbackQPaintDeviceWindow_Update3(this); };
	bool close() { return callbackQWindow_Close(this) != 0; };
	bool event(QEvent * ev) { return callbackQWindow_Event(this, ev) != 0; };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWindow_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, *result) != 0; };
	void Signal_ActiveChanged() { callbackQWindow_ActiveChanged(this); };
	void alert(int msec) { callbackQWindow_Alert(this, msec); };
	void Signal_ContentOrientationChanged(Qt::ScreenOrientation orientation) { callbackQWindow_ContentOrientationChanged(this, orientation); };
	void exposeEvent(QExposeEvent * ev) { callbackQWindow_ExposeEvent(this, ev); };
	void focusInEvent(QFocusEvent * ev) { callbackQWindow_FocusInEvent(this, ev); };
	void Signal_FocusObjectChanged(QObject * object) { callbackQWindow_FocusObjectChanged(this, object); };
	void focusOutEvent(QFocusEvent * ev) { callbackQWindow_FocusOutEvent(this, ev); };
	void Signal_HeightChanged(int arg) { callbackQWindow_HeightChanged(this, arg); };
	void hide() { callbackQWindow_Hide(this); };
	void hideEvent(QHideEvent * ev) { callbackQWindow_HideEvent(this, ev); };
	void keyPressEvent(QKeyEvent * ev) { callbackQWindow_KeyPressEvent(this, ev); };
	void keyReleaseEvent(QKeyEvent * ev) { callbackQWindow_KeyReleaseEvent(this, ev); };
	void lower() { callbackQWindow_Lower(this); };
	void Signal_MaximumHeightChanged(int arg) { callbackQWindow_MaximumHeightChanged(this, arg); };
	void Signal_MaximumWidthChanged(int arg) { callbackQWindow_MaximumWidthChanged(this, arg); };
	void Signal_MinimumHeightChanged(int arg) { callbackQWindow_MinimumHeightChanged(this, arg); };
	void Signal_MinimumWidthChanged(int arg) { callbackQWindow_MinimumWidthChanged(this, arg); };
	void Signal_ModalityChanged(Qt::WindowModality modality) { callbackQWindow_ModalityChanged(this, modality); };
	void mouseDoubleClickEvent(QMouseEvent * ev) { callbackQWindow_MouseDoubleClickEvent(this, ev); };
	void mouseMoveEvent(QMouseEvent * ev) { callbackQWindow_MouseMoveEvent(this, ev); };
	void mousePressEvent(QMouseEvent * ev) { callbackQWindow_MousePressEvent(this, ev); };
	void mouseReleaseEvent(QMouseEvent * ev) { callbackQWindow_MouseReleaseEvent(this, ev); };
	void moveEvent(QMoveEvent * ev) { callbackQWindow_MoveEvent(this, ev); };
	void Signal_OpacityChanged(qreal opacity) { callbackQWindow_OpacityChanged(this, opacity); };
	void raise() { callbackQWindow_Raise(this); };
	void requestActivate() { callbackQWindow_RequestActivate(this); };
	void requestUpdate() { callbackQWindow_RequestUpdate(this); };
	void resizeEvent(QResizeEvent * ev) { callbackQWindow_ResizeEvent(this, ev); };
	void Signal_ScreenChanged(QScreen * screen) { callbackQWindow_ScreenChanged(this, screen); };
	void setHeight(int arg) { callbackQWindow_SetHeight(this, arg); };
	void setMaximumHeight(int h) { callbackQWindow_SetMaximumHeight(this, h); };
	void setMaximumWidth(int w) { callbackQWindow_SetMaximumWidth(this, w); };
	void setMinimumHeight(int h) { callbackQWindow_SetMinimumHeight(this, h); };
	void setMinimumWidth(int w) { callbackQWindow_SetMinimumWidth(this, w); };
	void setTitle(const QString & vqs) { QByteArray tda39a3 = vqs.toUtf8(); QtGui_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };callbackQWindow_SetTitle(this, vqsPacked); };
	void setVisible(bool visible) { callbackQWindow_SetVisible(this, visible); };
	void setWidth(int arg) { callbackQWindow_SetWidth(this, arg); };
	void setX(int arg) { callbackQWindow_SetX(this, arg); };
	void setY(int arg) { callbackQWindow_SetY(this, arg); };
	void show() { callbackQWindow_Show(this); };
	void showEvent(QShowEvent * ev) { callbackQWindow_ShowEvent(this, ev); };
	void showFullScreen() { callbackQWindow_ShowFullScreen(this); };
	void showMaximized() { callbackQWindow_ShowMaximized(this); };
	void showMinimized() { callbackQWindow_ShowMinimized(this); };
	void showNormal() { callbackQWindow_ShowNormal(this); };
	void tabletEvent(QTabletEvent * ev) { callbackQWindow_TabletEvent(this, ev); };
	void touchEvent(QTouchEvent * ev) { callbackQWindow_TouchEvent(this, ev); };
	void Signal_VisibilityChanged(QWindow::Visibility visibility) { callbackQWindow_VisibilityChanged(this, visibility); };
	void Signal_VisibleChanged(bool arg) { callbackQWindow_VisibleChanged(this, arg); };
	void wheelEvent(QWheelEvent * ev) { callbackQWindow_WheelEvent(this, ev); };
	void Signal_WidthChanged(int arg) { callbackQWindow_WidthChanged(this, arg); };
	void Signal_WindowStateChanged(Qt::WindowState windowState) { callbackQWindow_WindowStateChanged(this, windowState); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray t3c6de1 = title.toUtf8(); QtGui_PackedString titlePacked = { const_cast<char*>(t3c6de1.prepend("WHITESPACE").constData()+10), t3c6de1.size()-10 };callbackQWindow_WindowTitleChanged(this, titlePacked); };
	void Signal_XChanged(int arg) { callbackQWindow_XChanged(this, arg); };
	void Signal_YChanged(int arg) { callbackQWindow_YChanged(this, arg); };
	QObject * focusObject() const { return static_cast<QObject*>(callbackQWindow_FocusObject(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize size() const { return *static_cast<QSize*>(callbackQWindow_Size(const_cast<void*>(static_cast<const void*>(this)))); };
	QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQWindow_Format(const_cast<void*>(static_cast<const void*>(this)))); };
	SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQWindow_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWindow_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQWindow_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWindow_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWindow_CustomEvent(this, event); };
	void deleteLater() { callbackQWindow_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWindow_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWindow_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQWindow_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWindow_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWindow_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPaintDeviceWindow_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};

void QPaintDeviceWindow_PaintEvent(void* ptr, void* event)
{
		static_cast<QPaintDeviceWindow*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}

void QPaintDeviceWindow_PaintEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::paintEvent(static_cast<QPaintEvent*>(event));
	} else {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::paintEvent(static_cast<QPaintEvent*>(event));
	}
}

void QPaintDeviceWindow_Update3(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "update");
}

void QPaintDeviceWindow_Update3Default(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::update();
	} else {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::update();
	}
}

void QPaintDeviceWindow_Update(void* ptr, void* rect)
{
		static_cast<QPaintDeviceWindow*>(ptr)->update(*static_cast<QRect*>(rect));
}

void QPaintDeviceWindow_Update2(void* ptr, void* region)
{
		static_cast<QPaintDeviceWindow*>(ptr)->update(*static_cast<QRegion*>(region));
}

void* QPaintDeviceWindow_PaintEngine(void* ptr)
{
		return static_cast<QPaintDeviceWindow*>(ptr)->paintEngine();
}

void* QPaintDeviceWindow_PaintEngineDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRasterWindow*>(ptr)->QRasterWindow::paintEngine();
	} else {
		return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::paintEngine();
	}
}

class MyQPaintEngine: public QPaintEngine
{
public:
	MyQPaintEngine(PaintEngineFeatures caps) : QPaintEngine(caps) {};
	bool end() { return callbackQPaintEngine_End(this) != 0; };
	void drawEllipse(const QRectF & rect) { callbackQPaintEngine_DrawEllipse(this, const_cast<QRectF*>(&rect)); };
	void drawImage(const QRectF & rectangle, const QImage & image, const QRectF & sr, Qt::ImageConversionFlags flags) { callbackQPaintEngine_DrawImage(this, const_cast<QRectF*>(&rectangle), const_cast<QImage*>(&image), const_cast<QRectF*>(&sr), flags); };
	void drawPolygon(const QPointF * points, int pointCount, QPaintEngine::PolygonDrawMode mode) { callbackQPaintEngine_DrawPolygon(this, const_cast<QPointF*>(points), pointCount, mode); };
	bool begin(QPaintDevice * pdev) { return callbackQPaintEngine_Begin(this, pdev) != 0; };
	void drawEllipse(const QRect & rect) { callbackQPaintEngine_DrawEllipse2(this, const_cast<QRect*>(&rect)); };
	void drawLines(const QLine * lines, int lineCount) { callbackQPaintEngine_DrawLines2(this, const_cast<QLine*>(lines), lineCount); };
	void drawLines(const QLineF * lines, int lineCount) { callbackQPaintEngine_DrawLines(this, const_cast<QLineF*>(lines), lineCount); };
	void drawPath(const QPainterPath & path) { callbackQPaintEngine_DrawPath(this, const_cast<QPainterPath*>(&path)); };
	void drawPixmap(const QRectF & r, const QPixmap & pm, const QRectF & sr) { callbackQPaintEngine_DrawPixmap(this, const_cast<QRectF*>(&r), const_cast<QPixmap*>(&pm), const_cast<QRectF*>(&sr)); };
	void drawPoints(const QPoint * points, int pointCount) { callbackQPaintEngine_DrawPoints2(this, const_cast<QPoint*>(points), pointCount); };
	void drawPoints(const QPointF * points, int pointCount) { callbackQPaintEngine_DrawPoints(this, const_cast<QPointF*>(points), pointCount); };
	void drawPolygon(const QPoint * points, int pointCount, QPaintEngine::PolygonDrawMode mode) { callbackQPaintEngine_DrawPolygon2(this, const_cast<QPoint*>(points), pointCount, mode); };
	void drawRects(const QRect * rects, int rectCount) { callbackQPaintEngine_DrawRects2(this, const_cast<QRect*>(rects), rectCount); };
	void drawRects(const QRectF * rects, int rectCount) { callbackQPaintEngine_DrawRects(this, const_cast<QRectF*>(rects), rectCount); };
	void drawTextItem(const QPointF & p, const QTextItem & textItem) { callbackQPaintEngine_DrawTextItem(this, const_cast<QPointF*>(&p), const_cast<QTextItem*>(&textItem)); };
	void drawTiledPixmap(const QRectF & rect, const QPixmap & pixmap, const QPointF & p) { callbackQPaintEngine_DrawTiledPixmap(this, const_cast<QRectF*>(&rect), const_cast<QPixmap*>(&pixmap), const_cast<QPointF*>(&p)); };
	void updateState(const QPaintEngineState & state) { callbackQPaintEngine_UpdateState(this, const_cast<QPaintEngineState*>(&state)); };
	 ~MyQPaintEngine() { callbackQPaintEngine_DestroyQPaintEngine(this); };
	Type type() const { return static_cast<QPaintEngine::Type>(callbackQPaintEngine_Type(const_cast<void*>(static_cast<const void*>(this)))); };
};

char QPaintEngine_End(void* ptr)
{
	return static_cast<QPaintEngine*>(ptr)->end();
}

void QPaintEngine_DrawEllipse(void* ptr, void* rect)
{
	static_cast<QPaintEngine*>(ptr)->drawEllipse(*static_cast<QRectF*>(rect));
}

void QPaintEngine_DrawEllipseDefault(void* ptr, void* rect)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawEllipse(*static_cast<QRectF*>(rect));
}

void QPaintEngine_DrawImage(void* ptr, void* rectangle, void* image, void* sr, long long flags)
{
	static_cast<QPaintEngine*>(ptr)->drawImage(*static_cast<QRectF*>(rectangle), *static_cast<QImage*>(image), *static_cast<QRectF*>(sr), static_cast<Qt::ImageConversionFlag>(flags));
}

void QPaintEngine_DrawImageDefault(void* ptr, void* rectangle, void* image, void* sr, long long flags)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawImage(*static_cast<QRectF*>(rectangle), *static_cast<QImage*>(image), *static_cast<QRectF*>(sr), static_cast<Qt::ImageConversionFlag>(flags));
}

void QPaintEngine_DrawPolygon(void* ptr, void* points, int pointCount, long long mode)
{
	static_cast<QPaintEngine*>(ptr)->drawPolygon(static_cast<QPointF*>(points), pointCount, static_cast<QPaintEngine::PolygonDrawMode>(mode));
}

void QPaintEngine_DrawPolygonDefault(void* ptr, void* points, int pointCount, long long mode)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawPolygon(static_cast<QPointF*>(points), pointCount, static_cast<QPaintEngine::PolygonDrawMode>(mode));
}

void* QPaintEngine_NewQPaintEngine(long long caps)
{
	return new MyQPaintEngine(static_cast<QPaintEngine::PaintEngineFeature>(caps));
}

char QPaintEngine_Begin(void* ptr, void* pdev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(pdev))) {
		return static_cast<QPaintEngine*>(ptr)->begin(static_cast<QPaintDeviceWindow*>(pdev));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(pdev))) {
		return static_cast<QPaintEngine*>(ptr)->begin(static_cast<QPdfWriter*>(pdev));
	} else {
		return static_cast<QPaintEngine*>(ptr)->begin(static_cast<QPaintDevice*>(pdev));
	}
}

void QPaintEngine_DrawEllipse2(void* ptr, void* rect)
{
	static_cast<QPaintEngine*>(ptr)->drawEllipse(*static_cast<QRect*>(rect));
}

void QPaintEngine_DrawEllipse2Default(void* ptr, void* rect)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawEllipse(*static_cast<QRect*>(rect));
}

void QPaintEngine_DrawLines2(void* ptr, void* lines, int lineCount)
{
	static_cast<QPaintEngine*>(ptr)->drawLines(static_cast<QLine*>(lines), lineCount);
}

void QPaintEngine_DrawLines2Default(void* ptr, void* lines, int lineCount)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawLines(static_cast<QLine*>(lines), lineCount);
}

void QPaintEngine_DrawLines(void* ptr, void* lines, int lineCount)
{
	static_cast<QPaintEngine*>(ptr)->drawLines(static_cast<QLineF*>(lines), lineCount);
}

void QPaintEngine_DrawLinesDefault(void* ptr, void* lines, int lineCount)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawLines(static_cast<QLineF*>(lines), lineCount);
}

void QPaintEngine_DrawPath(void* ptr, void* path)
{
	static_cast<QPaintEngine*>(ptr)->drawPath(*static_cast<QPainterPath*>(path));
}

void QPaintEngine_DrawPathDefault(void* ptr, void* path)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawPath(*static_cast<QPainterPath*>(path));
}

void QPaintEngine_DrawPixmap(void* ptr, void* r, void* pm, void* sr)
{
	static_cast<QPaintEngine*>(ptr)->drawPixmap(*static_cast<QRectF*>(r), *static_cast<QPixmap*>(pm), *static_cast<QRectF*>(sr));
}

void QPaintEngine_DrawPoints2(void* ptr, void* points, int pointCount)
{
	static_cast<QPaintEngine*>(ptr)->drawPoints(static_cast<QPoint*>(points), pointCount);
}

void QPaintEngine_DrawPoints2Default(void* ptr, void* points, int pointCount)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawPoints(static_cast<QPoint*>(points), pointCount);
}

void QPaintEngine_DrawPoints(void* ptr, void* points, int pointCount)
{
	static_cast<QPaintEngine*>(ptr)->drawPoints(static_cast<QPointF*>(points), pointCount);
}

void QPaintEngine_DrawPointsDefault(void* ptr, void* points, int pointCount)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawPoints(static_cast<QPointF*>(points), pointCount);
}

void QPaintEngine_DrawPolygon2(void* ptr, void* points, int pointCount, long long mode)
{
	static_cast<QPaintEngine*>(ptr)->drawPolygon(static_cast<QPoint*>(points), pointCount, static_cast<QPaintEngine::PolygonDrawMode>(mode));
}

void QPaintEngine_DrawPolygon2Default(void* ptr, void* points, int pointCount, long long mode)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawPolygon(static_cast<QPoint*>(points), pointCount, static_cast<QPaintEngine::PolygonDrawMode>(mode));
}

void QPaintEngine_DrawRects2(void* ptr, void* rects, int rectCount)
{
	static_cast<QPaintEngine*>(ptr)->drawRects(static_cast<QRect*>(rects), rectCount);
}

void QPaintEngine_DrawRects2Default(void* ptr, void* rects, int rectCount)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawRects(static_cast<QRect*>(rects), rectCount);
}

void QPaintEngine_DrawRects(void* ptr, void* rects, int rectCount)
{
	static_cast<QPaintEngine*>(ptr)->drawRects(static_cast<QRectF*>(rects), rectCount);
}

void QPaintEngine_DrawRectsDefault(void* ptr, void* rects, int rectCount)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawRects(static_cast<QRectF*>(rects), rectCount);
}

void QPaintEngine_DrawTextItem(void* ptr, void* p, void* textItem)
{
	static_cast<QPaintEngine*>(ptr)->drawTextItem(*static_cast<QPointF*>(p), *static_cast<QTextItem*>(textItem));
}

void QPaintEngine_DrawTextItemDefault(void* ptr, void* p, void* textItem)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawTextItem(*static_cast<QPointF*>(p), *static_cast<QTextItem*>(textItem));
}

void QPaintEngine_DrawTiledPixmap(void* ptr, void* rect, void* pixmap, void* p)
{
	static_cast<QPaintEngine*>(ptr)->drawTiledPixmap(*static_cast<QRectF*>(rect), *static_cast<QPixmap*>(pixmap), *static_cast<QPointF*>(p));
}

void QPaintEngine_DrawTiledPixmapDefault(void* ptr, void* rect, void* pixmap, void* p)
{
		static_cast<QPaintEngine*>(ptr)->QPaintEngine::drawTiledPixmap(*static_cast<QRectF*>(rect), *static_cast<QPixmap*>(pixmap), *static_cast<QPointF*>(p));
}

void QPaintEngine_SetActive(void* ptr, char state)
{
	static_cast<QPaintEngine*>(ptr)->setActive(state != 0);
}

void QPaintEngine_UpdateState(void* ptr, void* state)
{
	static_cast<QPaintEngine*>(ptr)->updateState(*static_cast<QPaintEngineState*>(state));
}

void QPaintEngine_DestroyQPaintEngine(void* ptr)
{
	static_cast<QPaintEngine*>(ptr)->~QPaintEngine();
}

void QPaintEngine_DestroyQPaintEngineDefault(void* ptr)
{

}

void* QPaintEngine_PaintDevice(void* ptr)
{
	return static_cast<QPaintEngine*>(ptr)->paintDevice();
}

void* QPaintEngine_Painter(void* ptr)
{
	return static_cast<QPaintEngine*>(ptr)->painter();
}

long long QPaintEngine_Type(void* ptr)
{
	return static_cast<QPaintEngine*>(ptr)->type();
}

char QPaintEngine_HasFeature(void* ptr, long long feature)
{
	return static_cast<QPaintEngine*>(ptr)->hasFeature(static_cast<QPaintEngine::PaintEngineFeature>(feature));
}

char QPaintEngine_IsActive(void* ptr)
{
	return static_cast<QPaintEngine*>(ptr)->isActive();
}

long long QPaintEngine_Gccaps(void* ptr)
{
	return static_cast<QPaintEngine*>(ptr)->gccaps;
}

void QPaintEngine_SetGccaps(void* ptr, long long vpa)
{
	static_cast<QPaintEngine*>(ptr)->gccaps = static_cast<QPaintEngine::PaintEngineFeature>(vpa);
}

void* QPaintEngine_State(void* ptr)
{
	return static_cast<QPaintEngine*>(ptr)->state;
}

void QPaintEngine_SetState(void* ptr, void* vqp)
{
	static_cast<QPaintEngine*>(ptr)->state = static_cast<QPaintEngineState*>(vqp);
}

void* QPaintEngineState_BackgroundBrush(void* ptr)
{
	return new QBrush(static_cast<QPaintEngineState*>(ptr)->backgroundBrush());
}

void* QPaintEngineState_Brush(void* ptr)
{
	return new QBrush(static_cast<QPaintEngineState*>(ptr)->brush());
}

void* QPaintEngineState_Font(void* ptr)
{
	return new QFont(static_cast<QPaintEngineState*>(ptr)->font());
}

long long QPaintEngineState_State(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->state();
}

void* QPaintEngineState_Painter(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->painter();
}

long long QPaintEngineState_CompositionMode(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->compositionMode();
}

long long QPaintEngineState_RenderHints(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->renderHints();
}

void* QPaintEngineState_ClipPath(void* ptr)
{
	return new QPainterPath(static_cast<QPaintEngineState*>(ptr)->clipPath());
}

void* QPaintEngineState_Pen(void* ptr)
{
	return new QPen(static_cast<QPaintEngineState*>(ptr)->pen());
}

void* QPaintEngineState_BrushOrigin(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QPaintEngineState*>(ptr)->brushOrigin(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QPaintEngineState_ClipRegion(void* ptr)
{
	return new QRegion(static_cast<QPaintEngineState*>(ptr)->clipRegion());
}

void* QPaintEngineState_Transform(void* ptr)
{
	return new QTransform(static_cast<QPaintEngineState*>(ptr)->transform());
}

long long QPaintEngineState_BackgroundMode(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->backgroundMode();
}

long long QPaintEngineState_ClipOperation(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->clipOperation();
}

char QPaintEngineState_BrushNeedsResolving(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->brushNeedsResolving();
}

char QPaintEngineState_IsClipEnabled(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->isClipEnabled();
}

char QPaintEngineState_PenNeedsResolving(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->penNeedsResolving();
}

double QPaintEngineState_Opacity(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->opacity();
}

long long QPaintEngineState_DirtyFlags(void* ptr)
{
	return static_cast<QPaintEngineState*>(ptr)->dirtyFlags;
}

void QPaintEngineState_SetDirtyFlags(void* ptr, long long vqp)
{
	static_cast<QPaintEngineState*>(ptr)->dirtyFlags = static_cast<QPaintEngine::DirtyFlag>(vqp);
}

class MyQPaintEvent: public QPaintEvent
{
public:
	MyQPaintEvent(const QRect &paintRect) : QPaintEvent(paintRect) {};
	MyQPaintEvent(const QRegion &paintRegion) : QPaintEvent(paintRegion) {};
};

void* QPaintEvent_NewQPaintEvent2(void* paintRect)
{
	return new MyQPaintEvent(*static_cast<QRect*>(paintRect));
}

void* QPaintEvent_NewQPaintEvent(void* paintRegion)
{
	return new MyQPaintEvent(*static_cast<QRegion*>(paintRegion));
}

void* QPaintEvent_Rect(void* ptr)
{
	return const_cast<QRect*>(&static_cast<QPaintEvent*>(ptr)->rect());
}

void* QPaintEvent_Region(void* ptr)
{
	return const_cast<QRegion*>(&static_cast<QPaintEvent*>(ptr)->region());
}

char QPaintEvent_M_erased(void* ptr)
{
	return static_cast<QPaintEvent*>(ptr)->m_erased;
}

void QPaintEvent_SetM_erased(void* ptr, char vbo)
{
	static_cast<QPaintEvent*>(ptr)->m_erased = vbo != 0;
}

void* QPaintEvent_M_rect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPaintEvent*>(ptr)->m_rect; new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QPaintEvent_SetM_rect(void* ptr, void* vqr)
{
	static_cast<QPaintEvent*>(ptr)->m_rect = *static_cast<QRect*>(vqr);
}

void* QPaintEvent_M_region(void* ptr)
{
	return new QRegion(static_cast<QPaintEvent*>(ptr)->m_region);
}

void QPaintEvent_SetM_region(void* ptr, void* vqr)
{
	static_cast<QPaintEvent*>(ptr)->m_region = *static_cast<QRegion*>(vqr);
}

void* QPainter_NewQPainter2(void* device)
{
	return new QPainter(static_cast<QPaintDevice*>(device));
}

void* QPainter_BoundingRect2(void* ptr, void* rectangle, int flags, char* text)
{
	return ({ QRect tmpValue = static_cast<QPainter*>(ptr)->boundingRect(*static_cast<QRect*>(rectangle), flags, QString(text)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPainter_BoundingRect4(void* ptr, void* rectangle, char* text, void* option)
{
	return ({ QRectF tmpValue = static_cast<QPainter*>(ptr)->boundingRect(*static_cast<QRectF*>(rectangle), QString(text), *static_cast<QTextOption*>(option)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPainter_BoundingRect(void* ptr, void* rectangle, int flags, char* text)
{
	return ({ QRectF tmpValue = static_cast<QPainter*>(ptr)->boundingRect(*static_cast<QRectF*>(rectangle), flags, QString(text)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

char QPainter_Begin(void* ptr, void* device)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(device))) {
		return static_cast<QPainter*>(ptr)->begin(static_cast<QPaintDeviceWindow*>(device));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(device))) {
		return static_cast<QPainter*>(ptr)->begin(static_cast<QPdfWriter*>(device));
	} else {
		return static_cast<QPainter*>(ptr)->begin(static_cast<QPaintDevice*>(device));
	}
}

void QPainter_DrawArc(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
	static_cast<QPainter*>(ptr)->drawArc(*static_cast<QRectF*>(rectangle), startAngle, spanAngle);
}

void* QPainter_NewQPainter()
{
	return new QPainter();
}

void* QPainter_BoundingRect3(void* ptr, int x, int y, int w, int h, int flags, char* text)
{
	return ({ QRect tmpValue = static_cast<QPainter*>(ptr)->boundingRect(x, y, w, h, flags, QString(text)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

char QPainter_End(void* ptr)
{
	return static_cast<QPainter*>(ptr)->end();
}

void QPainter_BeginNativePainting(void* ptr)
{
	static_cast<QPainter*>(ptr)->beginNativePainting();
}

void QPainter_DrawArc2(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
	static_cast<QPainter*>(ptr)->drawArc(*static_cast<QRect*>(rectangle), startAngle, spanAngle);
}

void QPainter_DrawArc3(void* ptr, int x, int y, int width, int height, int startAngle, int spanAngle)
{
	static_cast<QPainter*>(ptr)->drawArc(x, y, width, height, startAngle, spanAngle);
}

void QPainter_DrawChord3(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
	static_cast<QPainter*>(ptr)->drawChord(*static_cast<QRect*>(rectangle), startAngle, spanAngle);
}

void QPainter_DrawChord(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
	static_cast<QPainter*>(ptr)->drawChord(*static_cast<QRectF*>(rectangle), startAngle, spanAngle);
}

void QPainter_DrawChord2(void* ptr, int x, int y, int width, int height, int startAngle, int spanAngle)
{
	static_cast<QPainter*>(ptr)->drawChord(x, y, width, height, startAngle, spanAngle);
}

void QPainter_DrawConvexPolygon3(void* ptr, void* points, int pointCount)
{
	static_cast<QPainter*>(ptr)->drawConvexPolygon(static_cast<QPoint*>(points), pointCount);
}

void QPainter_DrawConvexPolygon(void* ptr, void* points, int pointCount)
{
	static_cast<QPainter*>(ptr)->drawConvexPolygon(static_cast<QPointF*>(points), pointCount);
}

void QPainter_DrawConvexPolygon4(void* ptr, void* polygon)
{
	static_cast<QPainter*>(ptr)->drawConvexPolygon(*static_cast<QPolygon*>(polygon));
}

void QPainter_DrawConvexPolygon2(void* ptr, void* polygon)
{
	static_cast<QPainter*>(ptr)->drawConvexPolygon(*static_cast<QPolygonF*>(polygon));
}

void QPainter_DrawEllipse5(void* ptr, void* center, int rx, int ry)
{
	static_cast<QPainter*>(ptr)->drawEllipse(*static_cast<QPoint*>(center), rx, ry);
}

void QPainter_DrawEllipse4(void* ptr, void* center, double rx, double ry)
{
	static_cast<QPainter*>(ptr)->drawEllipse(*static_cast<QPointF*>(center), rx, ry);
}

void QPainter_DrawEllipse2(void* ptr, void* rectangle)
{
	static_cast<QPainter*>(ptr)->drawEllipse(*static_cast<QRect*>(rectangle));
}

void QPainter_DrawEllipse(void* ptr, void* rectangle)
{
	static_cast<QPainter*>(ptr)->drawEllipse(*static_cast<QRectF*>(rectangle));
}

void QPainter_DrawEllipse3(void* ptr, int x, int y, int width, int height)
{
	static_cast<QPainter*>(ptr)->drawEllipse(x, y, width, height);
}

void QPainter_DrawGlyphRun(void* ptr, void* position, void* glyphs)
{
	static_cast<QPainter*>(ptr)->drawGlyphRun(*static_cast<QPointF*>(position), *static_cast<QGlyphRun*>(glyphs));
}

void QPainter_DrawImage8(void* ptr, void* point, void* image)
{
	static_cast<QPainter*>(ptr)->drawImage(*static_cast<QPoint*>(point), *static_cast<QImage*>(image));
}

void QPainter_DrawImage4(void* ptr, void* point, void* image, void* source, long long flags)
{
	static_cast<QPainter*>(ptr)->drawImage(*static_cast<QPoint*>(point), *static_cast<QImage*>(image), *static_cast<QRect*>(source), static_cast<Qt::ImageConversionFlag>(flags));
}

void QPainter_DrawImage7(void* ptr, void* point, void* image)
{
	static_cast<QPainter*>(ptr)->drawImage(*static_cast<QPointF*>(point), *static_cast<QImage*>(image));
}

void QPainter_DrawImage3(void* ptr, void* point, void* image, void* source, long long flags)
{
	static_cast<QPainter*>(ptr)->drawImage(*static_cast<QPointF*>(point), *static_cast<QImage*>(image), *static_cast<QRectF*>(source), static_cast<Qt::ImageConversionFlag>(flags));
}

void QPainter_DrawImage6(void* ptr, void* rectangle, void* image)
{
	static_cast<QPainter*>(ptr)->drawImage(*static_cast<QRect*>(rectangle), *static_cast<QImage*>(image));
}

void QPainter_DrawImage2(void* ptr, void* target, void* image, void* source, long long flags)
{
	static_cast<QPainter*>(ptr)->drawImage(*static_cast<QRect*>(target), *static_cast<QImage*>(image), *static_cast<QRect*>(source), static_cast<Qt::ImageConversionFlag>(flags));
}

void QPainter_DrawImage5(void* ptr, void* rectangle, void* image)
{
	static_cast<QPainter*>(ptr)->drawImage(*static_cast<QRectF*>(rectangle), *static_cast<QImage*>(image));
}

void QPainter_DrawImage(void* ptr, void* target, void* image, void* source, long long flags)
{
	static_cast<QPainter*>(ptr)->drawImage(*static_cast<QRectF*>(target), *static_cast<QImage*>(image), *static_cast<QRectF*>(source), static_cast<Qt::ImageConversionFlag>(flags));
}

void QPainter_DrawImage9(void* ptr, int x, int y, void* image, int sx, int sy, int sw, int sh, long long flags)
{
	static_cast<QPainter*>(ptr)->drawImage(x, y, *static_cast<QImage*>(image), sx, sy, sw, sh, static_cast<Qt::ImageConversionFlag>(flags));
}

void QPainter_DrawLine2(void* ptr, void* line)
{
	static_cast<QPainter*>(ptr)->drawLine(*static_cast<QLine*>(line));
}

void QPainter_DrawLine(void* ptr, void* line)
{
	static_cast<QPainter*>(ptr)->drawLine(*static_cast<QLineF*>(line));
}

void QPainter_DrawLine4(void* ptr, void* p1, void* p2)
{
	static_cast<QPainter*>(ptr)->drawLine(*static_cast<QPoint*>(p1), *static_cast<QPoint*>(p2));
}

void QPainter_DrawLine5(void* ptr, void* p1, void* p2)
{
	static_cast<QPainter*>(ptr)->drawLine(*static_cast<QPointF*>(p1), *static_cast<QPointF*>(p2));
}

void QPainter_DrawLine3(void* ptr, int x1, int y1, int x2, int y2)
{
	static_cast<QPainter*>(ptr)->drawLine(x1, y1, x2, y2);
}

void QPainter_DrawLines5(void* ptr, void* lines, int lineCount)
{
	static_cast<QPainter*>(ptr)->drawLines(static_cast<QLine*>(lines), lineCount);
}

void QPainter_DrawLines(void* ptr, void* lines, int lineCount)
{
	static_cast<QPainter*>(ptr)->drawLines(static_cast<QLineF*>(lines), lineCount);
}

void QPainter_DrawLines7(void* ptr, void* pointPairs, int lineCount)
{
	static_cast<QPainter*>(ptr)->drawLines(static_cast<QPoint*>(pointPairs), lineCount);
}

void QPainter_DrawLines3(void* ptr, void* pointPairs, int lineCount)
{
	static_cast<QPainter*>(ptr)->drawLines(static_cast<QPointF*>(pointPairs), lineCount);
}

void QPainter_DrawLines6(void* ptr, void* lines)
{
	static_cast<QPainter*>(ptr)->drawLines(*static_cast<QVector<QLine>*>(lines));
}

void QPainter_DrawLines2(void* ptr, void* lines)
{
	static_cast<QPainter*>(ptr)->drawLines(*static_cast<QVector<QLineF>*>(lines));
}

void QPainter_DrawLines8(void* ptr, void* pointPairs)
{
	static_cast<QPainter*>(ptr)->drawLines(*static_cast<QVector<QPoint>*>(pointPairs));
}

void QPainter_DrawLines4(void* ptr, void* pointPairs)
{
	static_cast<QPainter*>(ptr)->drawLines(*static_cast<QVector<QPointF>*>(pointPairs));
}

void QPainter_DrawPath(void* ptr, void* path)
{
	static_cast<QPainter*>(ptr)->drawPath(*static_cast<QPainterPath*>(path));
}

void QPainter_DrawPicture3(void* ptr, void* point, void* picture)
{
	static_cast<QPainter*>(ptr)->drawPicture(*static_cast<QPoint*>(point), *static_cast<QPicture*>(picture));
}

void QPainter_DrawPicture(void* ptr, void* point, void* picture)
{
	static_cast<QPainter*>(ptr)->drawPicture(*static_cast<QPointF*>(point), *static_cast<QPicture*>(picture));
}

void QPainter_DrawPicture2(void* ptr, int x, int y, void* picture)
{
	static_cast<QPainter*>(ptr)->drawPicture(x, y, *static_cast<QPicture*>(picture));
}

void QPainter_DrawPie3(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
	static_cast<QPainter*>(ptr)->drawPie(*static_cast<QRect*>(rectangle), startAngle, spanAngle);
}

void QPainter_DrawPie(void* ptr, void* rectangle, int startAngle, int spanAngle)
{
	static_cast<QPainter*>(ptr)->drawPie(*static_cast<QRectF*>(rectangle), startAngle, spanAngle);
}

void QPainter_DrawPie2(void* ptr, int x, int y, int width, int height, int startAngle, int spanAngle)
{
	static_cast<QPainter*>(ptr)->drawPie(x, y, width, height, startAngle, spanAngle);
}

void QPainter_DrawPixmap8(void* ptr, void* point, void* pixmap)
{
	static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QPoint*>(point), *static_cast<QPixmap*>(pixmap));
}

void QPainter_DrawPixmap6(void* ptr, void* point, void* pixmap, void* source)
{
	static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QPoint*>(point), *static_cast<QPixmap*>(pixmap), *static_cast<QRect*>(source));
}

void QPainter_DrawPixmap7(void* ptr, void* point, void* pixmap)
{
	static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QPointF*>(point), *static_cast<QPixmap*>(pixmap));
}

void QPainter_DrawPixmap5(void* ptr, void* point, void* pixmap, void* source)
{
	static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QPointF*>(point), *static_cast<QPixmap*>(pixmap), *static_cast<QRectF*>(source));
}

void QPainter_DrawPixmap10(void* ptr, void* rectangle, void* pixmap)
{
	static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QRect*>(rectangle), *static_cast<QPixmap*>(pixmap));
}

void QPainter_DrawPixmap2(void* ptr, void* target, void* pixmap, void* source)
{
	static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QRect*>(target), *static_cast<QPixmap*>(pixmap), *static_cast<QRect*>(source));
}

void QPainter_DrawPixmap(void* ptr, void* target, void* pixmap, void* source)
{
	static_cast<QPainter*>(ptr)->drawPixmap(*static_cast<QRectF*>(target), *static_cast<QPixmap*>(pixmap), *static_cast<QRectF*>(source));
}

void QPainter_DrawPixmap9(void* ptr, int x, int y, void* pixmap)
{
	static_cast<QPainter*>(ptr)->drawPixmap(x, y, *static_cast<QPixmap*>(pixmap));
}

void QPainter_DrawPixmap4(void* ptr, int x, int y, void* pixmap, int sx, int sy, int sw, int sh)
{
	static_cast<QPainter*>(ptr)->drawPixmap(x, y, *static_cast<QPixmap*>(pixmap), sx, sy, sw, sh);
}

void QPainter_DrawPixmap3(void* ptr, int x, int y, int w, int h, void* pixmap, int sx, int sy, int sw, int sh)
{
	static_cast<QPainter*>(ptr)->drawPixmap(x, y, w, h, *static_cast<QPixmap*>(pixmap), sx, sy, sw, sh);
}

void QPainter_DrawPixmap11(void* ptr, int x, int y, int width, int height, void* pixmap)
{
	static_cast<QPainter*>(ptr)->drawPixmap(x, y, width, height, *static_cast<QPixmap*>(pixmap));
}

void QPainter_DrawPoint2(void* ptr, void* position)
{
	static_cast<QPainter*>(ptr)->drawPoint(*static_cast<QPoint*>(position));
}

void QPainter_DrawPoint(void* ptr, void* position)
{
	static_cast<QPainter*>(ptr)->drawPoint(*static_cast<QPointF*>(position));
}

void QPainter_DrawPoint3(void* ptr, int x, int y)
{
	static_cast<QPainter*>(ptr)->drawPoint(x, y);
}

void QPainter_DrawPoints3(void* ptr, void* points, int pointCount)
{
	static_cast<QPainter*>(ptr)->drawPoints(static_cast<QPoint*>(points), pointCount);
}

void QPainter_DrawPoints(void* ptr, void* points, int pointCount)
{
	static_cast<QPainter*>(ptr)->drawPoints(static_cast<QPointF*>(points), pointCount);
}

void QPainter_DrawPoints4(void* ptr, void* points)
{
	static_cast<QPainter*>(ptr)->drawPoints(*static_cast<QPolygon*>(points));
}

void QPainter_DrawPoints2(void* ptr, void* points)
{
	static_cast<QPainter*>(ptr)->drawPoints(*static_cast<QPolygonF*>(points));
}

void QPainter_DrawPolygon3(void* ptr, void* points, int pointCount, long long fillRule)
{
	static_cast<QPainter*>(ptr)->drawPolygon(static_cast<QPoint*>(points), pointCount, static_cast<Qt::FillRule>(fillRule));
}

void QPainter_DrawPolygon(void* ptr, void* points, int pointCount, long long fillRule)
{
	static_cast<QPainter*>(ptr)->drawPolygon(static_cast<QPointF*>(points), pointCount, static_cast<Qt::FillRule>(fillRule));
}

void QPainter_DrawPolygon4(void* ptr, void* points, long long fillRule)
{
	static_cast<QPainter*>(ptr)->drawPolygon(*static_cast<QPolygon*>(points), static_cast<Qt::FillRule>(fillRule));
}

void QPainter_DrawPolygon2(void* ptr, void* points, long long fillRule)
{
	static_cast<QPainter*>(ptr)->drawPolygon(*static_cast<QPolygonF*>(points), static_cast<Qt::FillRule>(fillRule));
}

void QPainter_DrawPolyline3(void* ptr, void* points, int pointCount)
{
	static_cast<QPainter*>(ptr)->drawPolyline(static_cast<QPoint*>(points), pointCount);
}

void QPainter_DrawPolyline(void* ptr, void* points, int pointCount)
{
	static_cast<QPainter*>(ptr)->drawPolyline(static_cast<QPointF*>(points), pointCount);
}

void QPainter_DrawPolyline4(void* ptr, void* points)
{
	static_cast<QPainter*>(ptr)->drawPolyline(*static_cast<QPolygon*>(points));
}

void QPainter_DrawPolyline2(void* ptr, void* points)
{
	static_cast<QPainter*>(ptr)->drawPolyline(*static_cast<QPolygonF*>(points));
}

void QPainter_DrawRect3(void* ptr, void* rectangle)
{
	static_cast<QPainter*>(ptr)->drawRect(*static_cast<QRect*>(rectangle));
}

void QPainter_DrawRect(void* ptr, void* rectangle)
{
	static_cast<QPainter*>(ptr)->drawRect(*static_cast<QRectF*>(rectangle));
}

void QPainter_DrawRect2(void* ptr, int x, int y, int width, int height)
{
	static_cast<QPainter*>(ptr)->drawRect(x, y, width, height);
}

void QPainter_DrawRects3(void* ptr, void* rectangles, int rectCount)
{
	static_cast<QPainter*>(ptr)->drawRects(static_cast<QRect*>(rectangles), rectCount);
}

void QPainter_DrawRects(void* ptr, void* rectangles, int rectCount)
{
	static_cast<QPainter*>(ptr)->drawRects(static_cast<QRectF*>(rectangles), rectCount);
}

void QPainter_DrawRects4(void* ptr, void* rectangles)
{
	static_cast<QPainter*>(ptr)->drawRects(*static_cast<QVector<QRect>*>(rectangles));
}

void QPainter_DrawRects2(void* ptr, void* rectangles)
{
	static_cast<QPainter*>(ptr)->drawRects(*static_cast<QVector<QRectF>*>(rectangles));
}

void QPainter_DrawRoundedRect3(void* ptr, void* rect, double xRadius, double yRadius, long long mode)
{
	static_cast<QPainter*>(ptr)->drawRoundedRect(*static_cast<QRect*>(rect), xRadius, yRadius, static_cast<Qt::SizeMode>(mode));
}

void QPainter_DrawRoundedRect(void* ptr, void* rect, double xRadius, double yRadius, long long mode)
{
	static_cast<QPainter*>(ptr)->drawRoundedRect(*static_cast<QRectF*>(rect), xRadius, yRadius, static_cast<Qt::SizeMode>(mode));
}

void QPainter_DrawRoundedRect2(void* ptr, int x, int y, int w, int h, double xRadius, double yRadius, long long mode)
{
	static_cast<QPainter*>(ptr)->drawRoundedRect(x, y, w, h, xRadius, yRadius, static_cast<Qt::SizeMode>(mode));
}

void QPainter_DrawStaticText2(void* ptr, void* topLeftPosition, void* staticText)
{
	static_cast<QPainter*>(ptr)->drawStaticText(*static_cast<QPoint*>(topLeftPosition), *static_cast<QStaticText*>(staticText));
}

void QPainter_DrawStaticText(void* ptr, void* topLeftPosition, void* staticText)
{
	static_cast<QPainter*>(ptr)->drawStaticText(*static_cast<QPointF*>(topLeftPosition), *static_cast<QStaticText*>(staticText));
}

void QPainter_DrawStaticText3(void* ptr, int left, int top, void* staticText)
{
	static_cast<QPainter*>(ptr)->drawStaticText(left, top, *static_cast<QStaticText*>(staticText));
}

void QPainter_DrawText2(void* ptr, void* position, char* text)
{
	static_cast<QPainter*>(ptr)->drawText(*static_cast<QPoint*>(position), QString(text));
}

void QPainter_DrawText(void* ptr, void* position, char* text)
{
	static_cast<QPainter*>(ptr)->drawText(*static_cast<QPointF*>(position), QString(text));
}

void QPainter_DrawText6(void* ptr, void* rectangle, int flags, char* text, void* boundingRect)
{
	static_cast<QPainter*>(ptr)->drawText(*static_cast<QRect*>(rectangle), flags, QString(text), static_cast<QRect*>(boundingRect));
}

void QPainter_DrawText8(void* ptr, void* rectangle, char* text, void* option)
{
	static_cast<QPainter*>(ptr)->drawText(*static_cast<QRectF*>(rectangle), QString(text), *static_cast<QTextOption*>(option));
}

void QPainter_DrawText5(void* ptr, void* rectangle, int flags, char* text, void* boundingRect)
{
	static_cast<QPainter*>(ptr)->drawText(*static_cast<QRectF*>(rectangle), flags, QString(text), static_cast<QRectF*>(boundingRect));
}

void QPainter_DrawText3(void* ptr, int x, int y, char* text)
{
	static_cast<QPainter*>(ptr)->drawText(x, y, QString(text));
}

void QPainter_DrawText7(void* ptr, int x, int y, int width, int height, int flags, char* text, void* boundingRect)
{
	static_cast<QPainter*>(ptr)->drawText(x, y, width, height, flags, QString(text), static_cast<QRect*>(boundingRect));
}

void QPainter_DrawTiledPixmap3(void* ptr, void* rectangle, void* pixmap, void* position)
{
	static_cast<QPainter*>(ptr)->drawTiledPixmap(*static_cast<QRect*>(rectangle), *static_cast<QPixmap*>(pixmap), *static_cast<QPoint*>(position));
}

void QPainter_DrawTiledPixmap(void* ptr, void* rectangle, void* pixmap, void* position)
{
	static_cast<QPainter*>(ptr)->drawTiledPixmap(*static_cast<QRectF*>(rectangle), *static_cast<QPixmap*>(pixmap), *static_cast<QPointF*>(position));
}

void QPainter_DrawTiledPixmap2(void* ptr, int x, int y, int width, int height, void* pixmap, int sx, int sy)
{
	static_cast<QPainter*>(ptr)->drawTiledPixmap(x, y, width, height, *static_cast<QPixmap*>(pixmap), sx, sy);
}

void QPainter_EndNativePainting(void* ptr)
{
	static_cast<QPainter*>(ptr)->endNativePainting();
}

void QPainter_EraseRect3(void* ptr, void* rectangle)
{
	static_cast<QPainter*>(ptr)->eraseRect(*static_cast<QRect*>(rectangle));
}

void QPainter_EraseRect(void* ptr, void* rectangle)
{
	static_cast<QPainter*>(ptr)->eraseRect(*static_cast<QRectF*>(rectangle));
}

void QPainter_EraseRect2(void* ptr, int x, int y, int width, int height)
{
	static_cast<QPainter*>(ptr)->eraseRect(x, y, width, height);
}

void QPainter_FillPath(void* ptr, void* path, void* brush)
{
	static_cast<QPainter*>(ptr)->fillPath(*static_cast<QPainterPath*>(path), *static_cast<QBrush*>(brush));
}

void QPainter_FillRect11(void* ptr, void* rectangle, long long style)
{
	static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRect*>(rectangle), static_cast<Qt::BrushStyle>(style));
}

void QPainter_FillRect8(void* ptr, void* rectangle, long long color)
{
	static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRect*>(rectangle), static_cast<Qt::GlobalColor>(color));
}

void QPainter_FillRect3(void* ptr, void* rectangle, void* brush)
{
	static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRect*>(rectangle), *static_cast<QBrush*>(brush));
}

void QPainter_FillRect6(void* ptr, void* rectangle, void* color)
{
	static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRect*>(rectangle), *static_cast<QColor*>(color));
}

void QPainter_FillRect12(void* ptr, void* rectangle, long long style)
{
	static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRectF*>(rectangle), static_cast<Qt::BrushStyle>(style));
}

void QPainter_FillRect9(void* ptr, void* rectangle, long long color)
{
	static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRectF*>(rectangle), static_cast<Qt::GlobalColor>(color));
}

void QPainter_FillRect(void* ptr, void* rectangle, void* brush)
{
	static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRectF*>(rectangle), *static_cast<QBrush*>(brush));
}

void QPainter_FillRect4(void* ptr, void* rectangle, void* color)
{
	static_cast<QPainter*>(ptr)->fillRect(*static_cast<QRectF*>(rectangle), *static_cast<QColor*>(color));
}

void QPainter_FillRect10(void* ptr, int x, int y, int width, int height, long long style)
{
	static_cast<QPainter*>(ptr)->fillRect(x, y, width, height, static_cast<Qt::BrushStyle>(style));
}

void QPainter_FillRect7(void* ptr, int x, int y, int width, int height, long long color)
{
	static_cast<QPainter*>(ptr)->fillRect(x, y, width, height, static_cast<Qt::GlobalColor>(color));
}

void QPainter_FillRect2(void* ptr, int x, int y, int width, int height, void* brush)
{
	static_cast<QPainter*>(ptr)->fillRect(x, y, width, height, *static_cast<QBrush*>(brush));
}

void QPainter_FillRect5(void* ptr, int x, int y, int width, int height, void* color)
{
	static_cast<QPainter*>(ptr)->fillRect(x, y, width, height, *static_cast<QColor*>(color));
}

void QPainter_ResetTransform(void* ptr)
{
	static_cast<QPainter*>(ptr)->resetTransform();
}

void QPainter_Restore(void* ptr)
{
	static_cast<QPainter*>(ptr)->restore();
}

void QPainter_Rotate(void* ptr, double angle)
{
	static_cast<QPainter*>(ptr)->rotate(angle);
}

void QPainter_Save(void* ptr)
{
	static_cast<QPainter*>(ptr)->save();
}

void QPainter_Scale(void* ptr, double sx, double sy)
{
	static_cast<QPainter*>(ptr)->scale(sx, sy);
}

void QPainter_SetBackground(void* ptr, void* brush)
{
	static_cast<QPainter*>(ptr)->setBackground(*static_cast<QBrush*>(brush));
}

void QPainter_SetBackgroundMode(void* ptr, long long mode)
{
	static_cast<QPainter*>(ptr)->setBackgroundMode(static_cast<Qt::BGMode>(mode));
}

void QPainter_SetBrush2(void* ptr, long long style)
{
	static_cast<QPainter*>(ptr)->setBrush(static_cast<Qt::BrushStyle>(style));
}

void QPainter_SetBrush(void* ptr, void* brush)
{
	static_cast<QPainter*>(ptr)->setBrush(*static_cast<QBrush*>(brush));
}

void QPainter_SetBrushOrigin2(void* ptr, void* position)
{
	static_cast<QPainter*>(ptr)->setBrushOrigin(*static_cast<QPoint*>(position));
}

void QPainter_SetBrushOrigin(void* ptr, void* position)
{
	static_cast<QPainter*>(ptr)->setBrushOrigin(*static_cast<QPointF*>(position));
}

void QPainter_SetBrushOrigin3(void* ptr, int x, int y)
{
	static_cast<QPainter*>(ptr)->setBrushOrigin(x, y);
}

void QPainter_SetClipPath(void* ptr, void* path, long long operation)
{
	static_cast<QPainter*>(ptr)->setClipPath(*static_cast<QPainterPath*>(path), static_cast<Qt::ClipOperation>(operation));
}

void QPainter_SetClipRect2(void* ptr, void* rectangle, long long operation)
{
	static_cast<QPainter*>(ptr)->setClipRect(*static_cast<QRect*>(rectangle), static_cast<Qt::ClipOperation>(operation));
}

void QPainter_SetClipRect(void* ptr, void* rectangle, long long operation)
{
	static_cast<QPainter*>(ptr)->setClipRect(*static_cast<QRectF*>(rectangle), static_cast<Qt::ClipOperation>(operation));
}

void QPainter_SetClipRect3(void* ptr, int x, int y, int width, int height, long long operation)
{
	static_cast<QPainter*>(ptr)->setClipRect(x, y, width, height, static_cast<Qt::ClipOperation>(operation));
}

void QPainter_SetClipRegion(void* ptr, void* region, long long operation)
{
	static_cast<QPainter*>(ptr)->setClipRegion(*static_cast<QRegion*>(region), static_cast<Qt::ClipOperation>(operation));
}

void QPainter_SetClipping(void* ptr, char enable)
{
	static_cast<QPainter*>(ptr)->setClipping(enable != 0);
}

void QPainter_SetCompositionMode(void* ptr, long long mode)
{
	static_cast<QPainter*>(ptr)->setCompositionMode(static_cast<QPainter::CompositionMode>(mode));
}

void QPainter_SetFont(void* ptr, void* font)
{
	static_cast<QPainter*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QPainter_SetLayoutDirection(void* ptr, long long direction)
{
	static_cast<QPainter*>(ptr)->setLayoutDirection(static_cast<Qt::LayoutDirection>(direction));
}

void QPainter_SetOpacity(void* ptr, double opacity)
{
	static_cast<QPainter*>(ptr)->setOpacity(opacity);
}

void QPainter_SetPen3(void* ptr, long long style)
{
	static_cast<QPainter*>(ptr)->setPen(static_cast<Qt::PenStyle>(style));
}

void QPainter_SetPen2(void* ptr, void* color)
{
	static_cast<QPainter*>(ptr)->setPen(*static_cast<QColor*>(color));
}

void QPainter_SetPen(void* ptr, void* pen)
{
	static_cast<QPainter*>(ptr)->setPen(*static_cast<QPen*>(pen));
}

void QPainter_SetRenderHint(void* ptr, long long hint, char on)
{
	static_cast<QPainter*>(ptr)->setRenderHint(static_cast<QPainter::RenderHint>(hint), on != 0);
}

void QPainter_SetRenderHints(void* ptr, long long hints, char on)
{
	static_cast<QPainter*>(ptr)->setRenderHints(static_cast<QPainter::RenderHint>(hints), on != 0);
}

void QPainter_SetTransform(void* ptr, void* transform, char combine)
{
	static_cast<QPainter*>(ptr)->setTransform(*static_cast<QTransform*>(transform), combine != 0);
}

void QPainter_SetViewTransformEnabled(void* ptr, char enable)
{
	static_cast<QPainter*>(ptr)->setViewTransformEnabled(enable != 0);
}

void QPainter_SetViewport(void* ptr, void* rectangle)
{
	static_cast<QPainter*>(ptr)->setViewport(*static_cast<QRect*>(rectangle));
}

void QPainter_SetViewport2(void* ptr, int x, int y, int width, int height)
{
	static_cast<QPainter*>(ptr)->setViewport(x, y, width, height);
}

void QPainter_SetWindow(void* ptr, void* rectangle)
{
	static_cast<QPainter*>(ptr)->setWindow(*static_cast<QRect*>(rectangle));
}

void QPainter_SetWindow2(void* ptr, int x, int y, int width, int height)
{
	static_cast<QPainter*>(ptr)->setWindow(x, y, width, height);
}

void QPainter_SetWorldMatrixEnabled(void* ptr, char enable)
{
	static_cast<QPainter*>(ptr)->setWorldMatrixEnabled(enable != 0);
}

void QPainter_SetWorldTransform(void* ptr, void* matrix, char combine)
{
	static_cast<QPainter*>(ptr)->setWorldTransform(*static_cast<QTransform*>(matrix), combine != 0);
}

void QPainter_Shear(void* ptr, double sh, double sv)
{
	static_cast<QPainter*>(ptr)->shear(sh, sv);
}

void QPainter_StrokePath(void* ptr, void* path, void* pen)
{
	static_cast<QPainter*>(ptr)->strokePath(*static_cast<QPainterPath*>(path), *static_cast<QPen*>(pen));
}

void QPainter_Translate2(void* ptr, void* offset)
{
	static_cast<QPainter*>(ptr)->translate(*static_cast<QPoint*>(offset));
}

void QPainter_Translate(void* ptr, void* offset)
{
	static_cast<QPainter*>(ptr)->translate(*static_cast<QPointF*>(offset));
}

void QPainter_Translate3(void* ptr, double dx, double dy)
{
	static_cast<QPainter*>(ptr)->translate(dx, dy);
}

void QPainter_DestroyQPainter(void* ptr)
{
	static_cast<QPainter*>(ptr)->~QPainter();
}

long long QPainter_CompositionMode(void* ptr)
{
	return static_cast<QPainter*>(ptr)->compositionMode();
}

void* QPainter_FontInfo(void* ptr)
{
	return new QFontInfo(static_cast<QPainter*>(ptr)->fontInfo());
}

void* QPainter_FontMetrics(void* ptr)
{
	return new QFontMetrics(static_cast<QPainter*>(ptr)->fontMetrics());
}

void* QPainter_Device(void* ptr)
{
	return static_cast<QPainter*>(ptr)->device();
}

void* QPainter_PaintEngine(void* ptr)
{
	return static_cast<QPainter*>(ptr)->paintEngine();
}

void* QPainter_ClipPath(void* ptr)
{
	return new QPainterPath(static_cast<QPainter*>(ptr)->clipPath());
}

void* QPainter_BrushOrigin(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QPainter*>(ptr)->brushOrigin(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QPainter_Viewport(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPainter*>(ptr)->viewport(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPainter_Window(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPainter*>(ptr)->window(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPainter_ClipBoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QPainter*>(ptr)->clipBoundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPainter_ClipRegion(void* ptr)
{
	return new QRegion(static_cast<QPainter*>(ptr)->clipRegion());
}

void* QPainter_CombinedTransform(void* ptr)
{
	return new QTransform(static_cast<QPainter*>(ptr)->combinedTransform());
}

long long QPainter_BackgroundMode(void* ptr)
{
	return static_cast<QPainter*>(ptr)->backgroundMode();
}

long long QPainter_LayoutDirection(void* ptr)
{
	return static_cast<QPainter*>(ptr)->layoutDirection();
}

long long QPainter_RenderHints(void* ptr)
{
	return static_cast<QPainter*>(ptr)->renderHints();
}

char QPainter_HasClipping(void* ptr)
{
	return static_cast<QPainter*>(ptr)->hasClipping();
}

char QPainter_IsActive(void* ptr)
{
	return static_cast<QPainter*>(ptr)->isActive();
}

char QPainter_TestRenderHint(void* ptr, long long hint)
{
	return static_cast<QPainter*>(ptr)->testRenderHint(static_cast<QPainter::RenderHint>(hint));
}

char QPainter_ViewTransformEnabled(void* ptr)
{
	return static_cast<QPainter*>(ptr)->viewTransformEnabled();
}

char QPainter_WorldMatrixEnabled(void* ptr)
{
	return static_cast<QPainter*>(ptr)->worldMatrixEnabled();
}

void* QPainter_Background(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPainter*>(ptr)->background());
}

void* QPainter_Brush(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPainter*>(ptr)->brush());
}

void* QPainter_Font(void* ptr)
{
	return const_cast<QFont*>(&static_cast<QPainter*>(ptr)->font());
}

void* QPainter_Pen(void* ptr)
{
	return const_cast<QPen*>(&static_cast<QPainter*>(ptr)->pen());
}

void* QPainter_DeviceTransform(void* ptr)
{
	return const_cast<QTransform*>(&static_cast<QPainter*>(ptr)->deviceTransform());
}

void* QPainter_Transform(void* ptr)
{
	return const_cast<QTransform*>(&static_cast<QPainter*>(ptr)->transform());
}

void* QPainter_WorldTransform(void* ptr)
{
	return const_cast<QTransform*>(&static_cast<QPainter*>(ptr)->worldTransform());
}

double QPainter_Opacity(void* ptr)
{
	return static_cast<QPainter*>(ptr)->opacity();
}

void* QPainter___drawLines_lines_atList6(void* ptr, int i)
{
	return ({ QLine tmpValue = static_cast<QVector<QLine>*>(ptr)->at(i); new QLine(tmpValue.p1(), tmpValue.p2()); });
}

void QPainter___drawLines_lines_setList6(void* ptr, void* i)
{
	static_cast<QVector<QLine>*>(ptr)->append(*static_cast<QLine*>(i));
}

void* QPainter___drawLines_lines_newList6(void* ptr)
{
	return new QVector<QLine>;
}

void* QPainter___drawLines_lines_atList2(void* ptr, int i)
{
	return ({ QLineF tmpValue = static_cast<QVector<QLineF>*>(ptr)->at(i); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}

void QPainter___drawLines_lines_setList2(void* ptr, void* i)
{
	static_cast<QVector<QLineF>*>(ptr)->append(*static_cast<QLineF*>(i));
}

void* QPainter___drawLines_lines_newList2(void* ptr)
{
	return new QVector<QLineF>;
}

void* QPainter___drawLines_pointPairs_atList8(void* ptr, int i)
{
	return ({ QPoint tmpValue = static_cast<QVector<QPoint>*>(ptr)->at(i); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QPainter___drawLines_pointPairs_setList8(void* ptr, void* i)
{
	static_cast<QVector<QPoint>*>(ptr)->append(*static_cast<QPoint*>(i));
}

void* QPainter___drawLines_pointPairs_newList8(void* ptr)
{
	return new QVector<QPoint>;
}

void* QPainter___drawLines_pointPairs_atList4(void* ptr, int i)
{
	return ({ QPointF tmpValue = static_cast<QVector<QPointF>*>(ptr)->at(i); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QPainter___drawLines_pointPairs_setList4(void* ptr, void* i)
{
	static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}

void* QPainter___drawLines_pointPairs_newList4(void* ptr)
{
	return new QVector<QPointF>;
}

void* QPainter___drawRects_rectangles_atList4(void* ptr, int i)
{
	return ({ QRect tmpValue = static_cast<QVector<QRect>*>(ptr)->at(i); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QPainter___drawRects_rectangles_setList4(void* ptr, void* i)
{
	static_cast<QVector<QRect>*>(ptr)->append(*static_cast<QRect*>(i));
}

void* QPainter___drawRects_rectangles_newList4(void* ptr)
{
	return new QVector<QRect>;
}

void* QPainter___drawRects_rectangles_atList2(void* ptr, int i)
{
	return ({ QRectF tmpValue = static_cast<QVector<QRectF>*>(ptr)->at(i); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QPainter___drawRects_rectangles_setList2(void* ptr, void* i)
{
	static_cast<QVector<QRectF>*>(ptr)->append(*static_cast<QRectF*>(i));
}

void* QPainter___drawRects_rectangles_newList2(void* ptr)
{
	return new QVector<QRectF>;
}

void* QPainterPath_NewQPainterPath3(void* path)
{
	return new QPainterPath(*static_cast<QPainterPath*>(path));
}

void QPainterPath_AddEllipse(void* ptr, void* boundingRectangle)
{
	static_cast<QPainterPath*>(ptr)->addEllipse(*static_cast<QRectF*>(boundingRectangle));
}

void QPainterPath_AddPath(void* ptr, void* path)
{
	static_cast<QPainterPath*>(ptr)->addPath(*static_cast<QPainterPath*>(path));
}

void QPainterPath_AddRect(void* ptr, void* rectangle)
{
	static_cast<QPainterPath*>(ptr)->addRect(*static_cast<QRectF*>(rectangle));
}

void* QPainterPath_NewQPainterPath()
{
	return new QPainterPath();
}

void* QPainterPath_NewQPainterPath2(void* startPoint)
{
	return new QPainterPath(*static_cast<QPointF*>(startPoint));
}

void QPainterPath_AddEllipse3(void* ptr, void* center, double rx, double ry)
{
	static_cast<QPainterPath*>(ptr)->addEllipse(*static_cast<QPointF*>(center), rx, ry);
}

void QPainterPath_AddEllipse2(void* ptr, double x, double y, double width, double height)
{
	static_cast<QPainterPath*>(ptr)->addEllipse(x, y, width, height);
}

void QPainterPath_AddPolygon(void* ptr, void* polygon)
{
	static_cast<QPainterPath*>(ptr)->addPolygon(*static_cast<QPolygonF*>(polygon));
}

void QPainterPath_AddRect2(void* ptr, double x, double y, double width, double height)
{
	static_cast<QPainterPath*>(ptr)->addRect(x, y, width, height);
}

void QPainterPath_AddRegion(void* ptr, void* region)
{
	static_cast<QPainterPath*>(ptr)->addRegion(*static_cast<QRegion*>(region));
}

void QPainterPath_AddRoundedRect(void* ptr, void* rect, double xRadius, double yRadius, long long mode)
{
	static_cast<QPainterPath*>(ptr)->addRoundedRect(*static_cast<QRectF*>(rect), xRadius, yRadius, static_cast<Qt::SizeMode>(mode));
}

void QPainterPath_AddRoundedRect2(void* ptr, double x, double y, double w, double h, double xRadius, double yRadius, long long mode)
{
	static_cast<QPainterPath*>(ptr)->addRoundedRect(x, y, w, h, xRadius, yRadius, static_cast<Qt::SizeMode>(mode));
}

void QPainterPath_AddText(void* ptr, void* point, void* font, char* text)
{
	static_cast<QPainterPath*>(ptr)->addText(*static_cast<QPointF*>(point), *static_cast<QFont*>(font), QString(text));
}

void QPainterPath_AddText2(void* ptr, double x, double y, void* font, char* text)
{
	static_cast<QPainterPath*>(ptr)->addText(x, y, *static_cast<QFont*>(font), QString(text));
}

void QPainterPath_ArcMoveTo(void* ptr, void* rectangle, double angle)
{
	static_cast<QPainterPath*>(ptr)->arcMoveTo(*static_cast<QRectF*>(rectangle), angle);
}

void QPainterPath_ArcMoveTo2(void* ptr, double x, double y, double width, double height, double angle)
{
	static_cast<QPainterPath*>(ptr)->arcMoveTo(x, y, width, height, angle);
}

void QPainterPath_ArcTo(void* ptr, void* rectangle, double startAngle, double sweepLength)
{
	static_cast<QPainterPath*>(ptr)->arcTo(*static_cast<QRectF*>(rectangle), startAngle, sweepLength);
}

void QPainterPath_ArcTo2(void* ptr, double x, double y, double width, double height, double startAngle, double sweepLength)
{
	static_cast<QPainterPath*>(ptr)->arcTo(x, y, width, height, startAngle, sweepLength);
}

void QPainterPath_CloseSubpath(void* ptr)
{
	static_cast<QPainterPath*>(ptr)->closeSubpath();
}

void QPainterPath_ConnectPath(void* ptr, void* path)
{
	static_cast<QPainterPath*>(ptr)->connectPath(*static_cast<QPainterPath*>(path));
}

void QPainterPath_CubicTo(void* ptr, void* c1, void* c2, void* endPoint)
{
	static_cast<QPainterPath*>(ptr)->cubicTo(*static_cast<QPointF*>(c1), *static_cast<QPointF*>(c2), *static_cast<QPointF*>(endPoint));
}

void QPainterPath_CubicTo2(void* ptr, double c1X, double c1Y, double c2X, double c2Y, double endPointX, double endPointY)
{
	static_cast<QPainterPath*>(ptr)->cubicTo(c1X, c1Y, c2X, c2Y, endPointX, endPointY);
}

void QPainterPath_LineTo(void* ptr, void* endPoint)
{
	static_cast<QPainterPath*>(ptr)->lineTo(*static_cast<QPointF*>(endPoint));
}

void QPainterPath_LineTo2(void* ptr, double x, double y)
{
	static_cast<QPainterPath*>(ptr)->lineTo(x, y);
}

void QPainterPath_MoveTo(void* ptr, void* point)
{
	static_cast<QPainterPath*>(ptr)->moveTo(*static_cast<QPointF*>(point));
}

void QPainterPath_MoveTo2(void* ptr, double x, double y)
{
	static_cast<QPainterPath*>(ptr)->moveTo(x, y);
}

void QPainterPath_QuadTo(void* ptr, void* c, void* endPoint)
{
	static_cast<QPainterPath*>(ptr)->quadTo(*static_cast<QPointF*>(c), *static_cast<QPointF*>(endPoint));
}

void QPainterPath_QuadTo2(void* ptr, double cx, double cy, double endPointX, double endPointY)
{
	static_cast<QPainterPath*>(ptr)->quadTo(cx, cy, endPointX, endPointY);
}

void QPainterPath_SetElementPositionAt(void* ptr, int index, double x, double y)
{
	static_cast<QPainterPath*>(ptr)->setElementPositionAt(index, x, y);
}

void QPainterPath_SetFillRule(void* ptr, long long fillRule)
{
	static_cast<QPainterPath*>(ptr)->setFillRule(static_cast<Qt::FillRule>(fillRule));
}

void QPainterPath_Swap(void* ptr, void* other)
{
	static_cast<QPainterPath*>(ptr)->swap(*static_cast<QPainterPath*>(other));
}

void QPainterPath_Translate2(void* ptr, void* offset)
{
	static_cast<QPainterPath*>(ptr)->translate(*static_cast<QPointF*>(offset));
}

void QPainterPath_Translate(void* ptr, double dx, double dy)
{
	static_cast<QPainterPath*>(ptr)->translate(dx, dy);
}

void QPainterPath_DestroyQPainterPath(void* ptr)
{
	static_cast<QPainterPath*>(ptr)->~QPainterPath();
}

struct QtGui_PackedList QPainterPath_ToFillPolygons(void* ptr, void* matrix)
{
	return ({ QList<QPolygonF>* tmpValue = new QList<QPolygonF>(static_cast<QPainterPath*>(ptr)->toFillPolygons(*static_cast<QTransform*>(matrix))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QPainterPath_ToSubpathPolygons(void* ptr, void* matrix)
{
	return ({ QList<QPolygonF>* tmpValue = new QList<QPolygonF>(static_cast<QPainterPath*>(ptr)->toSubpathPolygons(*static_cast<QTransform*>(matrix))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QPainterPath_Intersected(void* ptr, void* p)
{
	return new QPainterPath(static_cast<QPainterPath*>(ptr)->intersected(*static_cast<QPainterPath*>(p)));
}

void* QPainterPath_Simplified(void* ptr)
{
	return new QPainterPath(static_cast<QPainterPath*>(ptr)->simplified());
}

void* QPainterPath_Subtracted(void* ptr, void* p)
{
	return new QPainterPath(static_cast<QPainterPath*>(ptr)->subtracted(*static_cast<QPainterPath*>(p)));
}

void* QPainterPath_ToReversed(void* ptr)
{
	return new QPainterPath(static_cast<QPainterPath*>(ptr)->toReversed());
}

void* QPainterPath_Translated2(void* ptr, void* offset)
{
	return new QPainterPath(static_cast<QPainterPath*>(ptr)->translated(*static_cast<QPointF*>(offset)));
}

void* QPainterPath_Translated(void* ptr, double dx, double dy)
{
	return new QPainterPath(static_cast<QPainterPath*>(ptr)->translated(dx, dy));
}

void* QPainterPath_United(void* ptr, void* p)
{
	return new QPainterPath(static_cast<QPainterPath*>(ptr)->united(*static_cast<QPainterPath*>(p)));
}

void* QPainterPath_CurrentPosition(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QPainterPath*>(ptr)->currentPosition(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QPainterPath_PointAtPercent(void* ptr, double t)
{
	return ({ QPointF tmpValue = static_cast<QPainterPath*>(ptr)->pointAtPercent(t); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QPainterPath_ToFillPolygon(void* ptr, void* matrix)
{
	return new QPolygonF(static_cast<QPainterPath*>(ptr)->toFillPolygon(*static_cast<QTransform*>(matrix)));
}

void* QPainterPath_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QPainterPath*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPainterPath_ControlPointRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QPainterPath*>(ptr)->controlPointRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

long long QPainterPath_FillRule(void* ptr)
{
	return static_cast<QPainterPath*>(ptr)->fillRule();
}

char QPainterPath_Contains3(void* ptr, void* p)
{
	return static_cast<QPainterPath*>(ptr)->contains(*static_cast<QPainterPath*>(p));
}

char QPainterPath_Contains(void* ptr, void* point)
{
	return static_cast<QPainterPath*>(ptr)->contains(*static_cast<QPointF*>(point));
}

char QPainterPath_Contains2(void* ptr, void* rectangle)
{
	return static_cast<QPainterPath*>(ptr)->contains(*static_cast<QRectF*>(rectangle));
}

char QPainterPath_Intersects2(void* ptr, void* p)
{
	return static_cast<QPainterPath*>(ptr)->intersects(*static_cast<QPainterPath*>(p));
}

char QPainterPath_Intersects(void* ptr, void* rectangle)
{
	return static_cast<QPainterPath*>(ptr)->intersects(*static_cast<QRectF*>(rectangle));
}

char QPainterPath_IsEmpty(void* ptr)
{
	return static_cast<QPainterPath*>(ptr)->isEmpty();
}

int QPainterPath_ElementCount(void* ptr)
{
	return static_cast<QPainterPath*>(ptr)->elementCount();
}

double QPainterPath_AngleAtPercent(void* ptr, double t)
{
	return static_cast<QPainterPath*>(ptr)->angleAtPercent(t);
}

double QPainterPath_Length(void* ptr)
{
	return static_cast<QPainterPath*>(ptr)->length();
}

double QPainterPath_PercentAtLength(void* ptr, double len)
{
	return static_cast<QPainterPath*>(ptr)->percentAtLength(len);
}

double QPainterPath_SlopeAtPercent(void* ptr, double t)
{
	return static_cast<QPainterPath*>(ptr)->slopeAtPercent(t);
}

void* QPainterPath___toFillPolygons_atList2(void* ptr, int i)
{
	return new QPolygonF(static_cast<QList<QPolygonF>*>(ptr)->at(i));
}

void QPainterPath___toFillPolygons_setList2(void* ptr, void* i)
{
	static_cast<QList<QPolygonF>*>(ptr)->append(*static_cast<QPolygonF*>(i));
}

void* QPainterPath___toFillPolygons_newList2(void* ptr)
{
	return new QList<QPolygonF>;
}

void* QPainterPath___toFillPolygons_atList(void* ptr, int i)
{
	return new QPolygonF(static_cast<QList<QPolygonF>*>(ptr)->at(i));
}

void QPainterPath___toFillPolygons_setList(void* ptr, void* i)
{
	static_cast<QList<QPolygonF>*>(ptr)->append(*static_cast<QPolygonF*>(i));
}

void* QPainterPath___toFillPolygons_newList(void* ptr)
{
	return new QList<QPolygonF>;
}

void* QPainterPath___toSubpathPolygons_atList2(void* ptr, int i)
{
	return new QPolygonF(static_cast<QList<QPolygonF>*>(ptr)->at(i));
}

void QPainterPath___toSubpathPolygons_setList2(void* ptr, void* i)
{
	static_cast<QList<QPolygonF>*>(ptr)->append(*static_cast<QPolygonF*>(i));
}

void* QPainterPath___toSubpathPolygons_newList2(void* ptr)
{
	return new QList<QPolygonF>;
}

void* QPainterPath___toSubpathPolygons_atList(void* ptr, int i)
{
	return new QPolygonF(static_cast<QList<QPolygonF>*>(ptr)->at(i));
}

void QPainterPath___toSubpathPolygons_setList(void* ptr, void* i)
{
	static_cast<QList<QPolygonF>*>(ptr)->append(*static_cast<QPolygonF*>(i));
}

void* QPainterPath___toSubpathPolygons_newList(void* ptr)
{
	return new QList<QPolygonF>;
}

void* QPainterPathStroker_NewQPainterPathStroker()
{
	return new QPainterPathStroker();
}

void* QPainterPathStroker_NewQPainterPathStroker2(void* pen)
{
	return new QPainterPathStroker(*static_cast<QPen*>(pen));
}

void QPainterPathStroker_SetCapStyle(void* ptr, long long style)
{
	static_cast<QPainterPathStroker*>(ptr)->setCapStyle(static_cast<Qt::PenCapStyle>(style));
}

void QPainterPathStroker_SetCurveThreshold(void* ptr, double threshold)
{
	static_cast<QPainterPathStroker*>(ptr)->setCurveThreshold(threshold);
}

void QPainterPathStroker_SetDashOffset(void* ptr, double offset)
{
	static_cast<QPainterPathStroker*>(ptr)->setDashOffset(offset);
}

void QPainterPathStroker_SetDashPattern(void* ptr, long long style)
{
	static_cast<QPainterPathStroker*>(ptr)->setDashPattern(static_cast<Qt::PenStyle>(style));
}

void QPainterPathStroker_SetDashPattern2(void* ptr, void* dashPattern)
{
	static_cast<QPainterPathStroker*>(ptr)->setDashPattern(*static_cast<QVector<qreal>*>(dashPattern));
}

void QPainterPathStroker_SetJoinStyle(void* ptr, long long style)
{
	static_cast<QPainterPathStroker*>(ptr)->setJoinStyle(static_cast<Qt::PenJoinStyle>(style));
}

void QPainterPathStroker_SetMiterLimit(void* ptr, double limit)
{
	static_cast<QPainterPathStroker*>(ptr)->setMiterLimit(limit);
}

void QPainterPathStroker_SetWidth(void* ptr, double width)
{
	static_cast<QPainterPathStroker*>(ptr)->setWidth(width);
}

void QPainterPathStroker_DestroyQPainterPathStroker(void* ptr)
{
	static_cast<QPainterPathStroker*>(ptr)->~QPainterPathStroker();
}

void* QPainterPathStroker_CreateStroke(void* ptr, void* path)
{
	return new QPainterPath(static_cast<QPainterPathStroker*>(ptr)->createStroke(*static_cast<QPainterPath*>(path)));
}

struct QtGui_PackedList QPainterPathStroker_DashPattern(void* ptr)
{
	return ({ QVector<qreal>* tmpValue = new QVector<qreal>(static_cast<QPainterPathStroker*>(ptr)->dashPattern()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

long long QPainterPathStroker_CapStyle(void* ptr)
{
	return static_cast<QPainterPathStroker*>(ptr)->capStyle();
}

long long QPainterPathStroker_JoinStyle(void* ptr)
{
	return static_cast<QPainterPathStroker*>(ptr)->joinStyle();
}

double QPainterPathStroker_CurveThreshold(void* ptr)
{
	return static_cast<QPainterPathStroker*>(ptr)->curveThreshold();
}

double QPainterPathStroker_DashOffset(void* ptr)
{
	return static_cast<QPainterPathStroker*>(ptr)->dashOffset();
}

double QPainterPathStroker_MiterLimit(void* ptr)
{
	return static_cast<QPainterPathStroker*>(ptr)->miterLimit();
}

double QPainterPathStroker_Width(void* ptr)
{
	return static_cast<QPainterPathStroker*>(ptr)->width();
}

double QPainterPathStroker___setDashPattern_dashPattern_atList2(void* ptr, int i)
{
	return static_cast<QVector<qreal>*>(ptr)->at(i);
}

void QPainterPathStroker___setDashPattern_dashPattern_setList2(void* ptr, double i)
{
	static_cast<QVector<qreal>*>(ptr)->append(i);
}

void* QPainterPathStroker___setDashPattern_dashPattern_newList2(void* ptr)
{
	return new QVector<qreal>;
}

double QPainterPathStroker___dashPattern_atList(void* ptr, int i)
{
	return static_cast<QVector<qreal>*>(ptr)->at(i);
}

void QPainterPathStroker___dashPattern_setList(void* ptr, double i)
{
	static_cast<QVector<qreal>*>(ptr)->append(i);
}

void* QPainterPathStroker___dashPattern_newList(void* ptr)
{
	return new QVector<qreal>;
}

int QPalette_NColorRoles_Type()
{
	return QPalette::NColorRoles;
}

void* QPalette_NewQPalette()
{
	return new QPalette();
}

void* QPalette_NewQPalette8(void* other)
{
	return new QPalette(*static_cast<QPalette*>(other));
}

void* QPalette_NewQPalette3(long long button)
{
	return new QPalette(static_cast<Qt::GlobalColor>(button));
}

void* QPalette_NewQPalette5(void* windowText, void* button, void* light, void* dark, void* mid, void* text, void* bright_text, void* base, void* window)
{
	return new QPalette(*static_cast<QBrush*>(windowText), *static_cast<QBrush*>(button), *static_cast<QBrush*>(light), *static_cast<QBrush*>(dark), *static_cast<QBrush*>(mid), *static_cast<QBrush*>(text), *static_cast<QBrush*>(bright_text), *static_cast<QBrush*>(base), *static_cast<QBrush*>(window));
}

void* QPalette_NewQPalette2(void* button)
{
	return new QPalette(*static_cast<QColor*>(button));
}

void* QPalette_NewQPalette4(void* button, void* window)
{
	return new QPalette(*static_cast<QColor*>(button), *static_cast<QColor*>(window));
}

void* QPalette_NewQPalette7(void* p)
{
	return new QPalette(*static_cast<QPalette*>(p));
}

void QPalette_SetBrush2(void* ptr, long long group, long long role, void* brush)
{
	static_cast<QPalette*>(ptr)->setBrush(static_cast<QPalette::ColorGroup>(group), static_cast<QPalette::ColorRole>(role), *static_cast<QBrush*>(brush));
}

void QPalette_SetBrush(void* ptr, long long role, void* brush)
{
	static_cast<QPalette*>(ptr)->setBrush(static_cast<QPalette::ColorRole>(role), *static_cast<QBrush*>(brush));
}

void QPalette_SetColor(void* ptr, long long group, long long role, void* color)
{
	static_cast<QPalette*>(ptr)->setColor(static_cast<QPalette::ColorGroup>(group), static_cast<QPalette::ColorRole>(role), *static_cast<QColor*>(color));
}

void QPalette_SetColor2(void* ptr, long long role, void* color)
{
	static_cast<QPalette*>(ptr)->setColor(static_cast<QPalette::ColorRole>(role), *static_cast<QColor*>(color));
}

void QPalette_SetColorGroup(void* ptr, long long cg, void* windowText, void* button, void* light, void* dark, void* mid, void* text, void* bright_text, void* base, void* window)
{
	static_cast<QPalette*>(ptr)->setColorGroup(static_cast<QPalette::ColorGroup>(cg), *static_cast<QBrush*>(windowText), *static_cast<QBrush*>(button), *static_cast<QBrush*>(light), *static_cast<QBrush*>(dark), *static_cast<QBrush*>(mid), *static_cast<QBrush*>(text), *static_cast<QBrush*>(bright_text), *static_cast<QBrush*>(base), *static_cast<QBrush*>(window));
}

void QPalette_SetCurrentColorGroup(void* ptr, long long cg)
{
	static_cast<QPalette*>(ptr)->setCurrentColorGroup(static_cast<QPalette::ColorGroup>(cg));
}

void QPalette_Swap(void* ptr, void* other)
{
	static_cast<QPalette*>(ptr)->swap(*static_cast<QPalette*>(other));
}

void QPalette_DestroyQPalette(void* ptr)
{
	static_cast<QPalette*>(ptr)->~QPalette();
}

long long QPalette_CurrentColorGroup(void* ptr)
{
	return static_cast<QPalette*>(ptr)->currentColorGroup();
}

void* QPalette_Resolve(void* ptr, void* other)
{
	return new QPalette(static_cast<QPalette*>(ptr)->resolve(*static_cast<QPalette*>(other)));
}

char QPalette_IsBrushSet(void* ptr, long long cg, long long cr)
{
	return static_cast<QPalette*>(ptr)->isBrushSet(static_cast<QPalette::ColorGroup>(cg), static_cast<QPalette::ColorRole>(cr));
}

char QPalette_IsCopyOf(void* ptr, void* p)
{
	return static_cast<QPalette*>(ptr)->isCopyOf(*static_cast<QPalette*>(p));
}

char QPalette_IsEqual(void* ptr, long long cg1, long long cg2)
{
	return static_cast<QPalette*>(ptr)->isEqual(static_cast<QPalette::ColorGroup>(cg1), static_cast<QPalette::ColorGroup>(cg2));
}

void* QPalette_AlternateBase(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->alternateBase());
}

void* QPalette_Base(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->base());
}

void* QPalette_BrightText(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->brightText());
}

void* QPalette_Brush(void* ptr, long long group, long long role)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->brush(static_cast<QPalette::ColorGroup>(group), static_cast<QPalette::ColorRole>(role)));
}

void* QPalette_Brush2(void* ptr, long long role)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->brush(static_cast<QPalette::ColorRole>(role)));
}

void* QPalette_Button(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->button());
}

void* QPalette_ButtonText(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->buttonText());
}

void* QPalette_Dark(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->dark());
}

void* QPalette_Highlight(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->highlight());
}

void* QPalette_HighlightedText(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->highlightedText());
}

void* QPalette_Light(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->light());
}

void* QPalette_Link(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->link());
}

void* QPalette_LinkVisited(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->linkVisited());
}

void* QPalette_Mid(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->mid());
}

void* QPalette_Midlight(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->midlight());
}

void* QPalette_Shadow(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->shadow());
}

void* QPalette_Text(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->text());
}

void* QPalette_ToolTipBase(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->toolTipBase());
}

void* QPalette_ToolTipText(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->toolTipText());
}

void* QPalette_Window(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->window());
}

void* QPalette_WindowText(void* ptr)
{
	return const_cast<QBrush*>(&static_cast<QPalette*>(ptr)->windowText());
}

void* QPalette_Color(void* ptr, long long group, long long role)
{
	return const_cast<QColor*>(&static_cast<QPalette*>(ptr)->color(static_cast<QPalette::ColorGroup>(group), static_cast<QPalette::ColorRole>(role)));
}

void* QPalette_Color2(void* ptr, long long role)
{
	return const_cast<QColor*>(&static_cast<QPalette*>(ptr)->color(static_cast<QPalette::ColorRole>(role)));
}

long long QPalette_CacheKey(void* ptr)
{
	return static_cast<QPalette*>(ptr)->cacheKey();
}

class MyQPdfWriter: public QPdfWriter
{
public:
	MyQPdfWriter(QIODevice *device) : QPdfWriter(device) {};
	MyQPdfWriter(const QString &filename) : QPdfWriter(filename) {};
	bool event(QEvent * e) { return callbackQPdfWriter_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQPdfWriter_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQPdfWriter_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQPdfWriter_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQPdfWriter_CustomEvent(this, event); };
	void deleteLater() { callbackQPdfWriter_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQPdfWriter_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQPdfWriter_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQPdfWriter_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQPdfWriter_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPdfWriter_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	bool newPage() { return callbackQPdfWriter_NewPage(this) != 0; };
	void setPageSize(QPagedPaintDevice::PageSize size) { callbackQPagedPaintDevice_SetPageSize2(this, size); };
	void setPageSizeMM(const QSizeF & size) { callbackQPagedPaintDevice_SetPageSizeMM(this, const_cast<QSizeF*>(&size)); };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPagedPaintDevice_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};

void* QPdfWriter_NewQPdfWriter2(void* device)
{
	return new MyQPdfWriter(static_cast<QIODevice*>(device));
}

void* QPdfWriter_NewQPdfWriter(char* filename)
{
	return new MyQPdfWriter(QString(filename));
}

void QPdfWriter_SetCreator(void* ptr, char* creator)
{
		static_cast<QPdfWriter*>(ptr)->setCreator(QString(creator));
}

void QPdfWriter_SetResolution(void* ptr, int resolution)
{
		static_cast<QPdfWriter*>(ptr)->setResolution(resolution);
}

void QPdfWriter_SetTitle(void* ptr, char* title)
{
		static_cast<QPdfWriter*>(ptr)->setTitle(QString(title));
}

void QPdfWriter_DestroyQPdfWriter(void* ptr)
{
	static_cast<QPdfWriter*>(ptr)->~QPdfWriter();
}

struct QtGui_PackedString QPdfWriter_Creator(void* ptr)
{
		return ({ QByteArray te95fa2 = static_cast<QPdfWriter*>(ptr)->creator().toUtf8(); QtGui_PackedString { const_cast<char*>(te95fa2.prepend("WHITESPACE").constData()+10), te95fa2.size()-10 }; });
}

struct QtGui_PackedString QPdfWriter_Title(void* ptr)
{
		return ({ QByteArray t5cd62a = static_cast<QPdfWriter*>(ptr)->title().toUtf8(); QtGui_PackedString { const_cast<char*>(t5cd62a.prepend("WHITESPACE").constData()+10), t5cd62a.size()-10 }; });
}

int QPdfWriter_Resolution(void* ptr)
{
		return static_cast<QPdfWriter*>(ptr)->resolution();
}

void* QPdfWriter___dynamicPropertyNames_atList(void* ptr, int i)
{
		return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QPdfWriter___dynamicPropertyNames_setList(void* ptr, void* i)
{
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QPdfWriter___dynamicPropertyNames_newList(void* ptr)
{
		return new QList<QByteArray>;
}

void* QPdfWriter___findChildren_atList2(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPdfWriter___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPdfWriter___findChildren_newList2(void* ptr)
{
		return new QList<QObject*>;
}

void* QPdfWriter___findChildren_atList3(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPdfWriter___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPdfWriter___findChildren_newList3(void* ptr)
{
		return new QList<QObject*>;
}

void* QPdfWriter___findChildren_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPdfWriter___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPdfWriter___findChildren_newList(void* ptr)
{
		return new QList<QObject*>;
}

void* QPdfWriter___children_atList(void* ptr, int i)
{
		return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QPdfWriter___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPdfWriter___children_newList(void* ptr)
{
		return new QList<QObject *>;
}

char QPdfWriter_Event(void* ptr, void* e)
{
		return static_cast<QPdfWriter*>(ptr)->event(static_cast<QEvent*>(e));
}

char QPdfWriter_EventDefault(void* ptr, void* e)
{
		return static_cast<QPdfWriter*>(ptr)->QPdfWriter::event(static_cast<QEvent*>(e));
}

char QPdfWriter_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QPdfWriter*>(ptr)->eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QPdfWriter*>(ptr)->eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QPdfWriter*>(ptr)->eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QPdfWriter*>(ptr)->eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QPdfWriter*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

char QPdfWriter_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QPdfWriter*>(ptr)->QPdfWriter::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QPdfWriter*>(ptr)->QPdfWriter::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QPdfWriter*>(ptr)->QPdfWriter::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QPdfWriter*>(ptr)->QPdfWriter::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QPdfWriter*>(ptr)->QPdfWriter::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QPdfWriter_ChildEvent(void* ptr, void* event)
{
		static_cast<QPdfWriter*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}

void QPdfWriter_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QPdfWriter*>(ptr)->QPdfWriter::childEvent(static_cast<QChildEvent*>(event));
}

void QPdfWriter_ConnectNotify(void* ptr, void* sign)
{
		static_cast<QPdfWriter*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPdfWriter_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QPdfWriter*>(ptr)->QPdfWriter::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPdfWriter_CustomEvent(void* ptr, void* event)
{
		static_cast<QPdfWriter*>(ptr)->customEvent(static_cast<QEvent*>(event));
}

void QPdfWriter_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QPdfWriter*>(ptr)->QPdfWriter::customEvent(static_cast<QEvent*>(event));
}

void QPdfWriter_DeleteLater(void* ptr)
{
		QMetaObject::invokeMethod(static_cast<QPdfWriter*>(ptr), "deleteLater");
}

void QPdfWriter_DeleteLaterDefault(void* ptr)
{
		static_cast<QPdfWriter*>(ptr)->QPdfWriter::deleteLater();
}

void QPdfWriter_DisconnectNotify(void* ptr, void* sign)
{
		static_cast<QPdfWriter*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPdfWriter_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QPdfWriter*>(ptr)->QPdfWriter::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QPdfWriter_TimerEvent(void* ptr, void* event)
{
		static_cast<QPdfWriter*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}

void QPdfWriter_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QPdfWriter*>(ptr)->QPdfWriter::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QPdfWriter_MetaObject(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QPdfWriter*>(ptr)->metaObject());
}

void* QPdfWriter_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QPdfWriter*>(ptr)->QPdfWriter::metaObject());
}

char QPdfWriter_NewPage(void* ptr)
{
		return static_cast<QPdfWriter*>(ptr)->newPage();
}

char QPdfWriter_NewPageDefault(void* ptr)
{
		return static_cast<QPdfWriter*>(ptr)->QPdfWriter::newPage();
}

void* QPen_NewQPen()
{
	return new QPen();
}

void* QPen_NewQPen6(void* pen)
{
	return new QPen(*static_cast<QPen*>(pen));
}

void* QPen_NewQPen2(long long style)
{
	return new QPen(static_cast<Qt::PenStyle>(style));
}

void* QPen_NewQPen4(void* brush, double width, long long style, long long cap, long long join)
{
	return new QPen(*static_cast<QBrush*>(brush), width, static_cast<Qt::PenStyle>(style), static_cast<Qt::PenCapStyle>(cap), static_cast<Qt::PenJoinStyle>(join));
}

void* QPen_NewQPen3(void* color)
{
	return new QPen(*static_cast<QColor*>(color));
}

void* QPen_NewQPen5(void* pen)
{
	return new QPen(*static_cast<QPen*>(pen));
}

void QPen_SetBrush(void* ptr, void* brush)
{
	static_cast<QPen*>(ptr)->setBrush(*static_cast<QBrush*>(brush));
}

void QPen_SetCapStyle(void* ptr, long long style)
{
	static_cast<QPen*>(ptr)->setCapStyle(static_cast<Qt::PenCapStyle>(style));
}

void QPen_SetColor(void* ptr, void* color)
{
	static_cast<QPen*>(ptr)->setColor(*static_cast<QColor*>(color));
}

void QPen_SetCosmetic(void* ptr, char cosmetic)
{
	static_cast<QPen*>(ptr)->setCosmetic(cosmetic != 0);
}

void QPen_SetDashOffset(void* ptr, double offset)
{
	static_cast<QPen*>(ptr)->setDashOffset(offset);
}

void QPen_SetDashPattern(void* ptr, void* pattern)
{
	static_cast<QPen*>(ptr)->setDashPattern(*static_cast<QVector<qreal>*>(pattern));
}

void QPen_SetJoinStyle(void* ptr, long long style)
{
	static_cast<QPen*>(ptr)->setJoinStyle(static_cast<Qt::PenJoinStyle>(style));
}

void QPen_SetMiterLimit(void* ptr, double limit)
{
	static_cast<QPen*>(ptr)->setMiterLimit(limit);
}

void QPen_SetStyle(void* ptr, long long style)
{
	static_cast<QPen*>(ptr)->setStyle(static_cast<Qt::PenStyle>(style));
}

void QPen_SetWidth(void* ptr, int width)
{
	static_cast<QPen*>(ptr)->setWidth(width);
}

void QPen_SetWidthF(void* ptr, double width)
{
	static_cast<QPen*>(ptr)->setWidthF(width);
}

void QPen_Swap(void* ptr, void* other)
{
	static_cast<QPen*>(ptr)->swap(*static_cast<QPen*>(other));
}

void QPen_DestroyQPen(void* ptr)
{
	static_cast<QPen*>(ptr)->~QPen();
}

void* QPen_Brush(void* ptr)
{
	return new QBrush(static_cast<QPen*>(ptr)->brush());
}

void* QPen_Color(void* ptr)
{
	return new QColor(static_cast<QPen*>(ptr)->color());
}

struct QtGui_PackedList QPen_DashPattern(void* ptr)
{
	return ({ QVector<qreal>* tmpValue = new QVector<qreal>(static_cast<QPen*>(ptr)->dashPattern()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

long long QPen_CapStyle(void* ptr)
{
	return static_cast<QPen*>(ptr)->capStyle();
}

long long QPen_JoinStyle(void* ptr)
{
	return static_cast<QPen*>(ptr)->joinStyle();
}

long long QPen_Style(void* ptr)
{
	return static_cast<QPen*>(ptr)->style();
}

char QPen_IsCosmetic(void* ptr)
{
	return static_cast<QPen*>(ptr)->isCosmetic();
}

char QPen_IsSolid(void* ptr)
{
	return static_cast<QPen*>(ptr)->isSolid();
}

int QPen_Width(void* ptr)
{
	return static_cast<QPen*>(ptr)->width();
}

double QPen_DashOffset(void* ptr)
{
	return static_cast<QPen*>(ptr)->dashOffset();
}

double QPen_MiterLimit(void* ptr)
{
	return static_cast<QPen*>(ptr)->miterLimit();
}

double QPen_WidthF(void* ptr)
{
	return static_cast<QPen*>(ptr)->widthF();
}

double QPen___setDashPattern_pattern_atList(void* ptr, int i)
{
	return static_cast<QVector<qreal>*>(ptr)->at(i);
}

void QPen___setDashPattern_pattern_setList(void* ptr, double i)
{
	static_cast<QVector<qreal>*>(ptr)->append(i);
}

void* QPen___setDashPattern_pattern_newList(void* ptr)
{
	return new QVector<qreal>;
}

double QPen___dashPattern_atList(void* ptr, int i)
{
	return static_cast<QVector<qreal>*>(ptr)->at(i);
}

void QPen___dashPattern_setList(void* ptr, double i)
{
	static_cast<QVector<qreal>*>(ptr)->append(i);
}

void* QPen___dashPattern_newList(void* ptr)
{
	return new QVector<qreal>;
}

class MyQPicture: public QPicture
{
public:
	MyQPicture(const QPicture &pic) : QPicture(pic) {};
	MyQPicture(int formatVersion) : QPicture(formatVersion) {};
	void setData(const char * data, uint size) { QtGui_PackedString dataPacked = { const_cast<char*>(data), size };callbackQPicture_SetData(this, dataPacked, size); };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPicture_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};

void* QPicture_NewQPicture2(void* pic)
{
	return new MyQPicture(*static_cast<QPicture*>(pic));
}

void* QPicture_NewQPicture(int formatVersion)
{
	return new MyQPicture(formatVersion);
}

char QPicture_Load2(void* ptr, void* dev, char* format)
{
	return static_cast<QPicture*>(ptr)->load(static_cast<QIODevice*>(dev), const_cast<const char*>(format));
}

char QPicture_Load(void* ptr, char* fileName, char* format)
{
	return static_cast<QPicture*>(ptr)->load(QString(fileName), const_cast<const char*>(format));
}

char QPicture_Play(void* ptr, void* painter)
{
	return static_cast<QPicture*>(ptr)->play(static_cast<QPainter*>(painter));
}

char QPicture_Save2(void* ptr, void* dev, char* format)
{
	return static_cast<QPicture*>(ptr)->save(static_cast<QIODevice*>(dev), const_cast<const char*>(format));
}

char QPicture_Save(void* ptr, char* fileName, char* format)
{
	return static_cast<QPicture*>(ptr)->save(QString(fileName), const_cast<const char*>(format));
}

void QPicture_SetBoundingRect(void* ptr, void* r)
{
	static_cast<QPicture*>(ptr)->setBoundingRect(*static_cast<QRect*>(r));
}

void QPicture_SetData(void* ptr, char* data, unsigned int size)
{
	static_cast<QPicture*>(ptr)->setData(const_cast<const char*>(data), size);
}

void QPicture_SetDataDefault(void* ptr, char* data, unsigned int size)
{
		static_cast<QPicture*>(ptr)->QPicture::setData(const_cast<const char*>(data), size);
}

void QPicture_Swap(void* ptr, void* other)
{
	static_cast<QPicture*>(ptr)->swap(*static_cast<QPicture*>(other));
}

void QPicture_DestroyQPicture(void* ptr)
{
	static_cast<QPicture*>(ptr)->~QPicture();
}

void* QPicture_BoundingRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPicture*>(ptr)->boundingRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

char QPicture_IsNull(void* ptr)
{
	return static_cast<QPicture*>(ptr)->isNull();
}

struct QtGui_PackedString QPicture_Data(void* ptr)
{
	return QtGui_PackedString { const_cast<char*>(static_cast<QPicture*>(ptr)->data()), static_cast<QPicture*>(ptr)->size() };
}

unsigned int QPicture_Size(void* ptr)
{
	return static_cast<QPicture*>(ptr)->size();
}

void* QPicture___inputFormats_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QPicture___inputFormats_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QPicture___inputFormats_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QPicture___outputFormats_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QPicture___outputFormats_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QPicture___outputFormats_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QPicture_PaintEngine(void* ptr)
{
	return static_cast<QPicture*>(ptr)->paintEngine();
}

void* QPicture_PaintEngineDefault(void* ptr)
{
		return static_cast<QPicture*>(ptr)->QPicture::paintEngine();
}

void* QPixelFormat_NewQPixelFormat()
{
	return new QPixelFormat();
}

void* QPixelFormat_NewQPixelFormat2(long long colorModel, char* firstSize, char* secondSize, char* thirdSize, char* fourthSize, char* fifthSize, char* alphaSize, long long alphaUsage, long long alphaPosition, long long premultiplied, long long typeInterpretation, long long byteOrder, char* subEnum)
{
	return new QPixelFormat(static_cast<QPixelFormat::ColorModel>(colorModel), *static_cast<uchar*>(static_cast<void*>(firstSize)), *static_cast<uchar*>(static_cast<void*>(secondSize)), *static_cast<uchar*>(static_cast<void*>(thirdSize)), *static_cast<uchar*>(static_cast<void*>(fourthSize)), *static_cast<uchar*>(static_cast<void*>(fifthSize)), *static_cast<uchar*>(static_cast<void*>(alphaSize)), static_cast<QPixelFormat::AlphaUsage>(alphaUsage), static_cast<QPixelFormat::AlphaPosition>(alphaPosition), static_cast<QPixelFormat::AlphaPremultiplied>(premultiplied), static_cast<QPixelFormat::TypeInterpretation>(typeInterpretation), static_cast<QPixelFormat::ByteOrder>(byteOrder), *static_cast<uchar*>(static_cast<void*>(subEnum)));
}

long long QPixelFormat_AlphaPosition(void* ptr)
{
	return static_cast<QPixelFormat*>(ptr)->alphaPosition();
}

long long QPixelFormat_Premultiplied(void* ptr)
{
	return static_cast<QPixelFormat*>(ptr)->premultiplied();
}

long long QPixelFormat_AlphaUsage(void* ptr)
{
	return static_cast<QPixelFormat*>(ptr)->alphaUsage();
}

long long QPixelFormat_ByteOrder(void* ptr)
{
	return static_cast<QPixelFormat*>(ptr)->byteOrder();
}

long long QPixelFormat_ColorModel(void* ptr)
{
	return static_cast<QPixelFormat*>(ptr)->colorModel();
}

long long QPixelFormat_TypeInterpretation(void* ptr)
{
	return static_cast<QPixelFormat*>(ptr)->typeInterpretation();
}

long long QPixelFormat_YuvLayout(void* ptr)
{
	return static_cast<QPixelFormat*>(ptr)->yuvLayout();
}

struct QtGui_PackedString QPixelFormat_AlphaSize(void* ptr)
{
	return ({ uchar pret9daa6f = static_cast<QPixelFormat*>(ptr)->alphaSize(); char* t9daa6f = static_cast<char*>(static_cast<void*>(&pret9daa6f)); QtGui_PackedString { t9daa6f, -1 }; });
}

struct QtGui_PackedString QPixelFormat_BitsPerPixel(void* ptr)
{
	return ({ uchar preta6a744 = static_cast<QPixelFormat*>(ptr)->bitsPerPixel(); char* ta6a744 = static_cast<char*>(static_cast<void*>(&preta6a744)); QtGui_PackedString { ta6a744, -1 }; });
}

struct QtGui_PackedString QPixelFormat_BlackSize(void* ptr)
{
	return ({ uchar pretb1416d = static_cast<QPixelFormat*>(ptr)->blackSize(); char* tb1416d = static_cast<char*>(static_cast<void*>(&pretb1416d)); QtGui_PackedString { tb1416d, -1 }; });
}

struct QtGui_PackedString QPixelFormat_BlueSize(void* ptr)
{
	return ({ uchar pretf9134a = static_cast<QPixelFormat*>(ptr)->blueSize(); char* tf9134a = static_cast<char*>(static_cast<void*>(&pretf9134a)); QtGui_PackedString { tf9134a, -1 }; });
}

struct QtGui_PackedString QPixelFormat_BrightnessSize(void* ptr)
{
	return ({ uchar pretd53fac = static_cast<QPixelFormat*>(ptr)->brightnessSize(); char* td53fac = static_cast<char*>(static_cast<void*>(&pretd53fac)); QtGui_PackedString { td53fac, -1 }; });
}

struct QtGui_PackedString QPixelFormat_ChannelCount(void* ptr)
{
	return ({ uchar pret704cf3 = static_cast<QPixelFormat*>(ptr)->channelCount(); char* t704cf3 = static_cast<char*>(static_cast<void*>(&pret704cf3)); QtGui_PackedString { t704cf3, -1 }; });
}

struct QtGui_PackedString QPixelFormat_CyanSize(void* ptr)
{
	return ({ uchar pret19e508 = static_cast<QPixelFormat*>(ptr)->cyanSize(); char* t19e508 = static_cast<char*>(static_cast<void*>(&pret19e508)); QtGui_PackedString { t19e508, -1 }; });
}

struct QtGui_PackedString QPixelFormat_GreenSize(void* ptr)
{
	return ({ uchar pret2cbd5e = static_cast<QPixelFormat*>(ptr)->greenSize(); char* t2cbd5e = static_cast<char*>(static_cast<void*>(&pret2cbd5e)); QtGui_PackedString { t2cbd5e, -1 }; });
}

struct QtGui_PackedString QPixelFormat_HueSize(void* ptr)
{
	return ({ uchar pret0f029c = static_cast<QPixelFormat*>(ptr)->hueSize(); char* t0f029c = static_cast<char*>(static_cast<void*>(&pret0f029c)); QtGui_PackedString { t0f029c, -1 }; });
}

struct QtGui_PackedString QPixelFormat_LightnessSize(void* ptr)
{
	return ({ uchar pretdfc9b5 = static_cast<QPixelFormat*>(ptr)->lightnessSize(); char* tdfc9b5 = static_cast<char*>(static_cast<void*>(&pretdfc9b5)); QtGui_PackedString { tdfc9b5, -1 }; });
}

struct QtGui_PackedString QPixelFormat_MagentaSize(void* ptr)
{
	return ({ uchar pret78ac06 = static_cast<QPixelFormat*>(ptr)->magentaSize(); char* t78ac06 = static_cast<char*>(static_cast<void*>(&pret78ac06)); QtGui_PackedString { t78ac06, -1 }; });
}

struct QtGui_PackedString QPixelFormat_RedSize(void* ptr)
{
	return ({ uchar pret1a20f5 = static_cast<QPixelFormat*>(ptr)->redSize(); char* t1a20f5 = static_cast<char*>(static_cast<void*>(&pret1a20f5)); QtGui_PackedString { t1a20f5, -1 }; });
}

struct QtGui_PackedString QPixelFormat_SaturationSize(void* ptr)
{
	return ({ uchar pretff1cd0 = static_cast<QPixelFormat*>(ptr)->saturationSize(); char* tff1cd0 = static_cast<char*>(static_cast<void*>(&pretff1cd0)); QtGui_PackedString { tff1cd0, -1 }; });
}

struct QtGui_PackedString QPixelFormat_YellowSize(void* ptr)
{
	return ({ uchar pret7b52e4 = static_cast<QPixelFormat*>(ptr)->yellowSize(); char* t7b52e4 = static_cast<char*>(static_cast<void*>(&pret7b52e4)); QtGui_PackedString { t7b52e4, -1 }; });
}

class MyQPixmap: public QPixmap
{
public:
	MyQPixmap() : QPixmap() {};
	MyQPixmap(const QPixmap &pixmap) : QPixmap(pixmap) {};
	MyQPixmap(const QSize &size) : QPixmap(size) {};
	MyQPixmap(const QString &fileName, const char *format, Qt::ImageConversionFlags flags) : QPixmap(fileName, format, flags) {};
	MyQPixmap(int width, int height) : QPixmap(width, height) {};
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPixmap_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};

void* QPixmap_QPixmap_FromImage(void* image, long long flags)
{
	return new QPixmap(QPixmap::fromImage(*static_cast<QImage*>(image), static_cast<Qt::ImageConversionFlag>(flags)));
}

void* QPixmap_QPixmap_FromImageReader(void* imageReader, long long flags)
{
	return new QPixmap(QPixmap::fromImageReader(static_cast<QImageReader*>(imageReader), static_cast<Qt::ImageConversionFlag>(flags)));
}

void* QPixmap_QPixmap_FromImage2(void* image, long long flags)
{
	return new QPixmap(QPixmap::fromImage(*static_cast<QImage*>(image), static_cast<Qt::ImageConversionFlag>(flags)));
}

void* QPixmap_NewQPixmap()
{
	return new MyQPixmap();
}

void* QPixmap_NewQPixmap7(void* pixmap)
{
	return new MyQPixmap(*static_cast<QPixmap*>(pixmap));
}

void* QPixmap_NewQPixmap4(void* size)
{
	return new MyQPixmap(*static_cast<QSize*>(size));
}

void* QPixmap_NewQPixmap5(char* fileName, char* format, long long flags)
{
	return new MyQPixmap(QString(fileName), const_cast<const char*>(format), static_cast<Qt::ImageConversionFlag>(flags));
}

void* QPixmap_NewQPixmap3(int width, int height)
{
	return new MyQPixmap(width, height);
}

void* QPixmap_QPixmap_TrueMatrix(void* matrix, int width, int height)
{
	return new QTransform(QPixmap::trueMatrix(*static_cast<QTransform*>(matrix), width, height));
}

char QPixmap_ConvertFromImage(void* ptr, void* image, long long flags)
{
	return static_cast<QPixmap*>(ptr)->convertFromImage(*static_cast<QImage*>(image), static_cast<Qt::ImageConversionFlag>(flags));
}

char QPixmap_Load(void* ptr, char* fileName, char* format, long long flags)
{
	return static_cast<QPixmap*>(ptr)->load(QString(fileName), const_cast<const char*>(format), static_cast<Qt::ImageConversionFlag>(flags));
}

char QPixmap_LoadFromData2(void* ptr, void* data, char* format, long long flags)
{
	return static_cast<QPixmap*>(ptr)->loadFromData(*static_cast<QByteArray*>(data), const_cast<const char*>(format), static_cast<Qt::ImageConversionFlag>(flags));
}

char QPixmap_LoadFromData(void* ptr, char* data, unsigned int len, char* format, long long flags)
{
	return static_cast<QPixmap*>(ptr)->loadFromData(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(data))), len, const_cast<const char*>(format), static_cast<Qt::ImageConversionFlag>(flags));
}

int QPixmap_QPixmap_DefaultDepth()
{
	return QPixmap::defaultDepth();
}

void QPixmap_Detach(void* ptr)
{
	static_cast<QPixmap*>(ptr)->detach();
}

void QPixmap_Fill(void* ptr, void* color)
{
	static_cast<QPixmap*>(ptr)->fill(*static_cast<QColor*>(color));
}

void QPixmap_Scroll2(void* ptr, int dx, int dy, void* rect, void* exposed)
{
	static_cast<QPixmap*>(ptr)->scroll(dx, dy, *static_cast<QRect*>(rect), static_cast<QRegion*>(exposed));
}

void QPixmap_Scroll(void* ptr, int dx, int dy, int x, int y, int width, int height, void* exposed)
{
	static_cast<QPixmap*>(ptr)->scroll(dx, dy, x, y, width, height, static_cast<QRegion*>(exposed));
}

void QPixmap_SetDevicePixelRatio(void* ptr, double scaleFactor)
{
	static_cast<QPixmap*>(ptr)->setDevicePixelRatio(scaleFactor);
}

void QPixmap_SetMask(void* ptr, void* mask)
{
	static_cast<QPixmap*>(ptr)->setMask(*static_cast<QBitmap*>(mask));
}

void QPixmap_Swap(void* ptr, void* other)
{
	static_cast<QPixmap*>(ptr)->swap(*static_cast<QPixmap*>(other));
}

void QPixmap_DestroyQPixmap(void* ptr)
{
	static_cast<QPixmap*>(ptr)->~QPixmap();
}

void* QPixmap_CreateHeuristicMask(void* ptr, char clipTight)
{
	return new QBitmap(static_cast<QPixmap*>(ptr)->createHeuristicMask(clipTight != 0));
}

void* QPixmap_CreateMaskFromColor(void* ptr, void* maskColor, long long mode)
{
	return new QBitmap(static_cast<QPixmap*>(ptr)->createMaskFromColor(*static_cast<QColor*>(maskColor), static_cast<Qt::MaskMode>(mode)));
}

void* QPixmap_Mask(void* ptr)
{
	return new QBitmap(static_cast<QPixmap*>(ptr)->mask());
}

void* QPixmap_ToImage(void* ptr)
{
	return new QImage(static_cast<QPixmap*>(ptr)->toImage());
}

void* QPixmap_Copy(void* ptr, void* rectangle)
{
	return new QPixmap(static_cast<QPixmap*>(ptr)->copy(*static_cast<QRect*>(rectangle)));
}

void* QPixmap_Copy2(void* ptr, int x, int y, int width, int height)
{
	return new QPixmap(static_cast<QPixmap*>(ptr)->copy(x, y, width, height));
}

void* QPixmap_Scaled(void* ptr, void* size, long long aspectRatioMode, long long transformMode)
{
	return new QPixmap(static_cast<QPixmap*>(ptr)->scaled(*static_cast<QSize*>(size), static_cast<Qt::AspectRatioMode>(aspectRatioMode), static_cast<Qt::TransformationMode>(transformMode)));
}

void* QPixmap_Scaled2(void* ptr, int width, int height, long long aspectRatioMode, long long transformMode)
{
	return new QPixmap(static_cast<QPixmap*>(ptr)->scaled(width, height, static_cast<Qt::AspectRatioMode>(aspectRatioMode), static_cast<Qt::TransformationMode>(transformMode)));
}

void* QPixmap_ScaledToHeight(void* ptr, int height, long long mode)
{
	return new QPixmap(static_cast<QPixmap*>(ptr)->scaledToHeight(height, static_cast<Qt::TransformationMode>(mode)));
}

void* QPixmap_ScaledToWidth(void* ptr, int width, long long mode)
{
	return new QPixmap(static_cast<QPixmap*>(ptr)->scaledToWidth(width, static_cast<Qt::TransformationMode>(mode)));
}

void* QPixmap_Transformed(void* ptr, void* transform, long long mode)
{
	return new QPixmap(static_cast<QPixmap*>(ptr)->transformed(*static_cast<QTransform*>(transform), static_cast<Qt::TransformationMode>(mode)));
}

void* QPixmap_Rect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPixmap*>(ptr)->rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QPixmap_Size(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QPixmap*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}

char QPixmap_HasAlpha(void* ptr)
{
	return static_cast<QPixmap*>(ptr)->hasAlpha();
}

char QPixmap_HasAlphaChannel(void* ptr)
{
	return static_cast<QPixmap*>(ptr)->hasAlphaChannel();
}

char QPixmap_IsNull(void* ptr)
{
	return static_cast<QPixmap*>(ptr)->isNull();
}

char QPixmap_IsQBitmap(void* ptr)
{
	return static_cast<QPixmap*>(ptr)->isQBitmap();
}

char QPixmap_Save2(void* ptr, void* device, char* format, int quality)
{
	return static_cast<QPixmap*>(ptr)->save(static_cast<QIODevice*>(device), const_cast<const char*>(format), quality);
}

char QPixmap_Save(void* ptr, char* fileName, char* format, int quality)
{
	return static_cast<QPixmap*>(ptr)->save(QString(fileName), const_cast<const char*>(format), quality);
}

long long QPixmap_CacheKey(void* ptr)
{
	return static_cast<QPixmap*>(ptr)->cacheKey();
}

double QPixmap_DevicePixelRatio(void* ptr)
{
	return static_cast<QPixmap*>(ptr)->devicePixelRatio();
}

void* QPixmap_PaintEngine(void* ptr)
{
	return static_cast<QPixmap*>(ptr)->paintEngine();
}

void* QPixmap_PaintEngineDefault(void* ptr)
{
	if (dynamic_cast<QBitmap*>(static_cast<QObject*>(ptr))) {
		return static_cast<QBitmap*>(ptr)->QBitmap::paintEngine();
	} else {
		return static_cast<QPixmap*>(ptr)->QPixmap::paintEngine();
	}
}

char QPixmapCache_QPixmapCache_Find(char* key, void* pixmap)
{
	return QPixmapCache::find(QString(key), static_cast<QPixmap*>(pixmap));
}

char QPixmapCache_QPixmapCache_Insert(char* key, void* pixmap)
{
	return QPixmapCache::insert(QString(key), *static_cast<QPixmap*>(pixmap));
}

int QPixmapCache_QPixmapCache_CacheLimit()
{
	return QPixmapCache::cacheLimit();
}

void QPixmapCache_QPixmapCache_Clear()
{
	QPixmapCache::clear();
}

void QPixmapCache_QPixmapCache_Remove(char* key)
{
	QPixmapCache::remove(QString(key));
}

void QPixmapCache_QPixmapCache_SetCacheLimit(int n)
{
	QPixmapCache::setCacheLimit(n);
}

class MyQPlatformSurfaceEvent: public QPlatformSurfaceEvent
{
public:
	MyQPlatformSurfaceEvent(SurfaceEventType surfaceEventType) : QPlatformSurfaceEvent(surfaceEventType) {};
};

void* QPlatformSurfaceEvent_NewQPlatformSurfaceEvent(long long surfaceEventType)
{
	return new MyQPlatformSurfaceEvent(static_cast<QPlatformSurfaceEvent::SurfaceEventType>(surfaceEventType));
}

long long QPlatformSurfaceEvent_SurfaceEventType(void* ptr)
{
	return static_cast<QPlatformSurfaceEvent*>(ptr)->surfaceEventType();
}

long long QPlatformSurfaceEvent_M_surfaceEventType(void* ptr)
{
	return static_cast<QPlatformSurfaceEvent*>(ptr)->m_surfaceEventType;
}

void QPlatformSurfaceEvent_SetM_surfaceEventType(void* ptr, long long vsu)
{
	static_cast<QPlatformSurfaceEvent*>(ptr)->m_surfaceEventType = static_cast<QPlatformSurfaceEvent::SurfaceEventType>(vsu);
}

void* QPointingDeviceUniqueId_QPointingDeviceUniqueId_FromNumericId(long long id)
{
	return new QPointingDeviceUniqueId(QPointingDeviceUniqueId::fromNumericId(id));
}

void* QPointingDeviceUniqueId_NewQPointingDeviceUniqueId()
{
	return new QPointingDeviceUniqueId();
}

char QPointingDeviceUniqueId_IsValid(void* ptr)
{
	return static_cast<QPointingDeviceUniqueId*>(ptr)->isValid();
}

long long QPointingDeviceUniqueId_NumericId(void* ptr)
{
	return static_cast<QPointingDeviceUniqueId*>(ptr)->numericId();
}

void* QPolygon_NewQPolygon()
{
	return new QPolygon();
}

void* QPolygon_NewQPolygon8(void* other)
{
	return new QPolygon(*static_cast<QPolygon*>(other));
}

void* QPolygon_NewQPolygon4(void* v)
{
	return new QPolygon(*static_cast<QVector<QPoint>*>(v));
}

void* QPolygon_NewQPolygon7(void* polygon)
{
	return new QPolygon(*static_cast<QPolygon*>(polygon));
}

void* QPolygon_NewQPolygon5(void* rectangle, char closed)
{
	return new QPolygon(*static_cast<QRect*>(rectangle), closed != 0);
}

void* QPolygon_NewQPolygon3(void* points)
{
	return new QPolygon(*static_cast<QVector<QPoint>*>(points));
}

void* QPolygon_NewQPolygon2(int size)
{
	return new QPolygon(size);
}

void QPolygon_PutPoints3(void* ptr, int index, int nPoints, void* fromPolygon, int fromIndex)
{
	static_cast<QPolygon*>(ptr)->putPoints(index, nPoints, *static_cast<QPolygon*>(fromPolygon), fromIndex);
}

void QPolygon_SetPoint2(void* ptr, int index, void* point)
{
	static_cast<QPolygon*>(ptr)->setPoint(index, *static_cast<QPoint*>(point));
}

void QPolygon_SetPoint(void* ptr, int index, int x, int y)
{
	static_cast<QPolygon*>(ptr)->setPoint(index, x, y);
}

void QPolygon_SetPoints(void* ptr, int nPoints, int points)
{
	static_cast<QPolygon*>(ptr)->setPoints(nPoints, const_cast<const int*>(&points));
}

void QPolygon_Swap(void* ptr, void* other)
{
	static_cast<QPolygon*>(ptr)->swap(*static_cast<QPolygon*>(other));
}

void QPolygon_Translate2(void* ptr, void* offset)
{
	static_cast<QPolygon*>(ptr)->translate(*static_cast<QPoint*>(offset));
}

void QPolygon_Translate(void* ptr, int dx, int dy)
{
	static_cast<QPolygon*>(ptr)->translate(dx, dy);
}

void QPolygon_DestroyQPolygon(void* ptr)
{
	static_cast<QPolygon*>(ptr)->~QPolygon();
}

void* QPolygon_Point2(void* ptr, int index)
{
	return ({ QPoint tmpValue = static_cast<QPolygon*>(ptr)->point(index); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QPolygon_Intersected(void* ptr, void* r)
{
	return new QPolygon(static_cast<QPolygon*>(ptr)->intersected(*static_cast<QPolygon*>(r)));
}

void* QPolygon_Subtracted(void* ptr, void* r)
{
	return new QPolygon(static_cast<QPolygon*>(ptr)->subtracted(*static_cast<QPolygon*>(r)));
}

void* QPolygon_Translated2(void* ptr, void* offset)
{
	return new QPolygon(static_cast<QPolygon*>(ptr)->translated(*static_cast<QPoint*>(offset)));
}

void* QPolygon_Translated(void* ptr, int dx, int dy)
{
	return new QPolygon(static_cast<QPolygon*>(ptr)->translated(dx, dy));
}

void* QPolygon_United(void* ptr, void* r)
{
	return new QPolygon(static_cast<QPolygon*>(ptr)->united(*static_cast<QPolygon*>(r)));
}

void* QPolygon_BoundingRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QPolygon*>(ptr)->boundingRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

char QPolygon_ContainsPoint(void* ptr, void* point, long long fillRule)
{
	return static_cast<QPolygon*>(ptr)->containsPoint(*static_cast<QPoint*>(point), static_cast<Qt::FillRule>(fillRule));
}

void QPolygon_Point(void* ptr, int index, int x, int y)
{
	static_cast<QPolygon*>(ptr)->point(index, &x, &y);
}

void* QPolygon___QPolygon_v_atList4(void* ptr, int i)
{
	return ({ QPoint tmpValue = static_cast<QVector<QPoint>*>(ptr)->at(i); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QPolygon___QPolygon_v_setList4(void* ptr, void* i)
{
	static_cast<QVector<QPoint>*>(ptr)->append(*static_cast<QPoint*>(i));
}

void* QPolygon___QPolygon_v_newList4(void* ptr)
{
	return new QVector<QPoint>;
}

void* QPolygon___QPolygon_points_atList3(void* ptr, int i)
{
	return ({ QPoint tmpValue = static_cast<QVector<QPoint>*>(ptr)->at(i); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QPolygon___QPolygon_points_setList3(void* ptr, void* i)
{
	static_cast<QVector<QPoint>*>(ptr)->append(*static_cast<QPoint*>(i));
}

void* QPolygon___QPolygon_points_newList3(void* ptr)
{
	return new QVector<QPoint>;
}

void* QPolygon___QVector_other_atList5(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygon___QVector_other_setList5(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygon___QVector_other_newList5(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygon___QVector_other_atList4(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygon___QVector_other_setList4(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygon___QVector_other_newList4(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygon___fill_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygon___fill_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygon___fill_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygon___fromList_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygon___fromList_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygon___fromList_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygon___fromList_list_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygon___fromList_list_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygon___fromList_list_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygon___fromStdVector_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygon___fromStdVector_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygon___fromStdVector_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygon___append_value_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygon___append_value_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygon___append_value_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygon___swap_other_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygon___swap_other_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygon___swap_other_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygon___toList_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygon___toList_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygon___toList_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygon___mid_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygon___mid_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygon___mid_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygonF_NewQPolygonF()
{
	return new QPolygonF();
}

void* QPolygonF_NewQPolygonF8(void* other)
{
	return new QPolygonF(*static_cast<QPolygonF*>(other));
}

void* QPolygonF_NewQPolygonF4(void* v)
{
	return new QPolygonF(*static_cast<QVector<QPointF>*>(v));
}

void* QPolygonF_NewQPolygonF6(void* polygon)
{
	return new QPolygonF(*static_cast<QPolygon*>(polygon));
}

void* QPolygonF_NewQPolygonF7(void* polygon)
{
	return new QPolygonF(*static_cast<QPolygonF*>(polygon));
}

void* QPolygonF_NewQPolygonF5(void* rectangle)
{
	return new QPolygonF(*static_cast<QRectF*>(rectangle));
}

void* QPolygonF_NewQPolygonF3(void* points)
{
	return new QPolygonF(*static_cast<QVector<QPointF>*>(points));
}

void* QPolygonF_NewQPolygonF2(int size)
{
	return new QPolygonF(size);
}

void QPolygonF_Swap(void* ptr, void* other)
{
	static_cast<QPolygonF*>(ptr)->swap(*static_cast<QPolygonF*>(other));
}

void QPolygonF_Translate(void* ptr, void* offset)
{
	static_cast<QPolygonF*>(ptr)->translate(*static_cast<QPointF*>(offset));
}

void QPolygonF_Translate2(void* ptr, double dx, double dy)
{
	static_cast<QPolygonF*>(ptr)->translate(dx, dy);
}

void QPolygonF_DestroyQPolygonF(void* ptr)
{
	static_cast<QPolygonF*>(ptr)->~QPolygonF();
}

void* QPolygonF_ToPolygon(void* ptr)
{
	return new QPolygon(static_cast<QPolygonF*>(ptr)->toPolygon());
}

void* QPolygonF_Intersected(void* ptr, void* r)
{
	return new QPolygonF(static_cast<QPolygonF*>(ptr)->intersected(*static_cast<QPolygonF*>(r)));
}

void* QPolygonF_Subtracted(void* ptr, void* r)
{
	return new QPolygonF(static_cast<QPolygonF*>(ptr)->subtracted(*static_cast<QPolygonF*>(r)));
}

void* QPolygonF_Translated(void* ptr, void* offset)
{
	return new QPolygonF(static_cast<QPolygonF*>(ptr)->translated(*static_cast<QPointF*>(offset)));
}

void* QPolygonF_Translated2(void* ptr, double dx, double dy)
{
	return new QPolygonF(static_cast<QPolygonF*>(ptr)->translated(dx, dy));
}

void* QPolygonF_United(void* ptr, void* r)
{
	return new QPolygonF(static_cast<QPolygonF*>(ptr)->united(*static_cast<QPolygonF*>(r)));
}

void* QPolygonF_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QPolygonF*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

char QPolygonF_ContainsPoint(void* ptr, void* point, long long fillRule)
{
	return static_cast<QPolygonF*>(ptr)->containsPoint(*static_cast<QPointF*>(point), static_cast<Qt::FillRule>(fillRule));
}

char QPolygonF_IsClosed(void* ptr)
{
	return static_cast<QPolygonF*>(ptr)->isClosed();
}

void* QPolygonF___QPolygonF_v_atList4(void* ptr, int i)
{
	return ({ QPointF tmpValue = static_cast<QVector<QPointF>*>(ptr)->at(i); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QPolygonF___QPolygonF_v_setList4(void* ptr, void* i)
{
	static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}

void* QPolygonF___QPolygonF_v_newList4(void* ptr)
{
	return new QVector<QPointF>;
}

void* QPolygonF___QPolygonF_points_atList3(void* ptr, int i)
{
	return ({ QPointF tmpValue = static_cast<QVector<QPointF>*>(ptr)->at(i); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QPolygonF___QPolygonF_points_setList3(void* ptr, void* i)
{
	static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}

void* QPolygonF___QPolygonF_points_newList3(void* ptr)
{
	return new QVector<QPointF>;
}

void* QPolygonF___QVector_other_atList5(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygonF___QVector_other_setList5(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygonF___QVector_other_newList5(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygonF___QVector_other_atList4(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygonF___QVector_other_setList4(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygonF___QVector_other_newList4(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygonF___fill_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygonF___fill_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygonF___fill_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygonF___fromList_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygonF___fromList_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygonF___fromList_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygonF___fromList_list_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygonF___fromList_list_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygonF___fromList_list_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygonF___fromStdVector_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygonF___fromStdVector_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygonF___fromStdVector_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygonF___append_value_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygonF___append_value_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygonF___append_value_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygonF___swap_other_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygonF___swap_other_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygonF___swap_other_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygonF___toList_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygonF___toList_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygonF___toList_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QPolygonF___mid_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QPolygonF___mid_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QPolygonF___mid_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QQuaternion_QQuaternion_FromAxes(void* xAxis, void* yAxis, void* zAxis)
{
	return new QQuaternion(QQuaternion::fromAxes(*static_cast<QVector3D*>(xAxis), *static_cast<QVector3D*>(yAxis), *static_cast<QVector3D*>(zAxis)));
}

void* QQuaternion_QQuaternion_FromAxisAndAngle(void* axis, float angle)
{
	return new QQuaternion(QQuaternion::fromAxisAndAngle(*static_cast<QVector3D*>(axis), angle));
}

void* QQuaternion_QQuaternion_FromAxisAndAngle2(float x, float y, float z, float angle)
{
	return new QQuaternion(QQuaternion::fromAxisAndAngle(x, y, z, angle));
}

void* QQuaternion_QQuaternion_FromDirection(void* direction, void* up)
{
	return new QQuaternion(QQuaternion::fromDirection(*static_cast<QVector3D*>(direction), *static_cast<QVector3D*>(up)));
}

void* QQuaternion_QQuaternion_FromEulerAngles2(void* eulerAngles)
{
	return new QQuaternion(QQuaternion::fromEulerAngles(*static_cast<QVector3D*>(eulerAngles)));
}

void* QQuaternion_QQuaternion_FromEulerAngles(float pitch, float yaw, float roll)
{
	return new QQuaternion(QQuaternion::fromEulerAngles(pitch, yaw, roll));
}

void* QQuaternion_QQuaternion_Nlerp(void* q1, void* q2, float t)
{
	return new QQuaternion(QQuaternion::nlerp(*static_cast<QQuaternion*>(q1), *static_cast<QQuaternion*>(q2), t));
}

void* QQuaternion_QQuaternion_RotationTo(void* from, void* to)
{
	return new QQuaternion(QQuaternion::rotationTo(*static_cast<QVector3D*>(from), *static_cast<QVector3D*>(to)));
}

void* QQuaternion_QQuaternion_Slerp(void* q1, void* q2, float t)
{
	return new QQuaternion(QQuaternion::slerp(*static_cast<QQuaternion*>(q1), *static_cast<QQuaternion*>(q2), t));
}

void* QQuaternion_NewQQuaternion()
{
	return new QQuaternion();
}

void* QQuaternion_NewQQuaternion5(void* vector)
{
	return new QQuaternion(*static_cast<QVector4D*>(vector));
}

void* QQuaternion_NewQQuaternion4(float scalar, void* vector)
{
	return new QQuaternion(scalar, *static_cast<QVector3D*>(vector));
}

void* QQuaternion_NewQQuaternion3(float scalar, float xpos, float ypos, float zpos)
{
	return new QQuaternion(scalar, xpos, ypos, zpos);
}

float QQuaternion_QQuaternion_DotProduct(void* q1, void* q2)
{
	return QQuaternion::dotProduct(*static_cast<QQuaternion*>(q1), *static_cast<QQuaternion*>(q2));
}

void QQuaternion_Normalize(void* ptr)
{
	static_cast<QQuaternion*>(ptr)->normalize();
}

void QQuaternion_SetScalar(void* ptr, float scalar)
{
	static_cast<QQuaternion*>(ptr)->setScalar(scalar);
}

void QQuaternion_SetVector(void* ptr, void* vector)
{
	static_cast<QQuaternion*>(ptr)->setVector(*static_cast<QVector3D*>(vector));
}

void QQuaternion_SetVector2(void* ptr, float x, float y, float z)
{
	static_cast<QQuaternion*>(ptr)->setVector(x, y, z);
}

void QQuaternion_SetX(void* ptr, float x)
{
	static_cast<QQuaternion*>(ptr)->setX(x);
}

void QQuaternion_SetY(void* ptr, float y)
{
	static_cast<QQuaternion*>(ptr)->setY(y);
}

void QQuaternion_SetZ(void* ptr, float z)
{
	static_cast<QQuaternion*>(ptr)->setZ(z);
}

void* QQuaternion_Conjugated(void* ptr)
{
	return new QQuaternion(static_cast<QQuaternion*>(ptr)->conjugated());
}

void* QQuaternion_Inverted(void* ptr)
{
	return new QQuaternion(static_cast<QQuaternion*>(ptr)->inverted());
}

void* QQuaternion_Normalized(void* ptr)
{
	return new QQuaternion(static_cast<QQuaternion*>(ptr)->normalized());
}

void* QQuaternion_RotatedVector(void* ptr, void* vector)
{
	return new QVector3D(static_cast<QQuaternion*>(ptr)->rotatedVector(*static_cast<QVector3D*>(vector)));
}

void* QQuaternion_ToEulerAngles(void* ptr)
{
	return new QVector3D(static_cast<QQuaternion*>(ptr)->toEulerAngles());
}

void* QQuaternion_Vector(void* ptr)
{
	return new QVector3D(static_cast<QQuaternion*>(ptr)->vector());
}

void* QQuaternion_ToVector4D(void* ptr)
{
	return new QVector4D(static_cast<QQuaternion*>(ptr)->toVector4D());
}

char QQuaternion_IsIdentity(void* ptr)
{
	return static_cast<QQuaternion*>(ptr)->isIdentity();
}

char QQuaternion_IsNull(void* ptr)
{
	return static_cast<QQuaternion*>(ptr)->isNull();
}

float QQuaternion_Length(void* ptr)
{
	return static_cast<QQuaternion*>(ptr)->length();
}

float QQuaternion_LengthSquared(void* ptr)
{
	return static_cast<QQuaternion*>(ptr)->lengthSquared();
}

float QQuaternion_Scalar(void* ptr)
{
	return static_cast<QQuaternion*>(ptr)->scalar();
}

float QQuaternion_X(void* ptr)
{
	return static_cast<QQuaternion*>(ptr)->x();
}

float QQuaternion_Y(void* ptr)
{
	return static_cast<QQuaternion*>(ptr)->y();
}

float QQuaternion_Z(void* ptr)
{
	return static_cast<QQuaternion*>(ptr)->z();
}

void QQuaternion_GetAxes(void* ptr, void* xAxis, void* yAxis, void* zAxis)
{
	static_cast<QQuaternion*>(ptr)->getAxes(static_cast<QVector3D*>(xAxis), static_cast<QVector3D*>(yAxis), static_cast<QVector3D*>(zAxis));
}

void QQuaternion_GetAxisAndAngle2(void* ptr, void* axis, float angle)
{
	static_cast<QQuaternion*>(ptr)->getAxisAndAngle(static_cast<QVector3D*>(axis), &angle);
}

void QQuaternion_GetAxisAndAngle(void* ptr, float x, float y, float z, float angle)
{
	static_cast<QQuaternion*>(ptr)->getAxisAndAngle(&x, &y, &z, &angle);
}

void QQuaternion_GetEulerAngles(void* ptr, float pitch, float yaw, float roll)
{
	static_cast<QQuaternion*>(ptr)->getEulerAngles(&pitch, &yaw, &roll);
}

void* QRadialGradient_NewQRadialGradient()
{
	return new QRadialGradient();
}

void* QRadialGradient_NewQRadialGradient6(void* center, double centerRadius, void* focalPoint, double focalRadius)
{
	return new QRadialGradient(*static_cast<QPointF*>(center), centerRadius, *static_cast<QPointF*>(focalPoint), focalRadius);
}

void* QRadialGradient_NewQRadialGradient4(void* center, double radius)
{
	return new QRadialGradient(*static_cast<QPointF*>(center), radius);
}

void* QRadialGradient_NewQRadialGradient2(void* center, double radius, void* focalPoint)
{
	return new QRadialGradient(*static_cast<QPointF*>(center), radius, *static_cast<QPointF*>(focalPoint));
}

void* QRadialGradient_NewQRadialGradient7(double cx, double cy, double centerRadius, double fx, double fy, double focalRadius)
{
	return new QRadialGradient(cx, cy, centerRadius, fx, fy, focalRadius);
}

void* QRadialGradient_NewQRadialGradient5(double cx, double cy, double radius)
{
	return new QRadialGradient(cx, cy, radius);
}

void* QRadialGradient_NewQRadialGradient3(double cx, double cy, double radius, double fx, double fy)
{
	return new QRadialGradient(cx, cy, radius, fx, fy);
}

void QRadialGradient_SetCenter(void* ptr, void* center)
{
	static_cast<QRadialGradient*>(ptr)->setCenter(*static_cast<QPointF*>(center));
}

void QRadialGradient_SetCenter2(void* ptr, double x, double y)
{
	static_cast<QRadialGradient*>(ptr)->setCenter(x, y);
}

void QRadialGradient_SetCenterRadius(void* ptr, double radius)
{
	static_cast<QRadialGradient*>(ptr)->setCenterRadius(radius);
}

void QRadialGradient_SetFocalPoint(void* ptr, void* focalPoint)
{
	static_cast<QRadialGradient*>(ptr)->setFocalPoint(*static_cast<QPointF*>(focalPoint));
}

void QRadialGradient_SetFocalPoint2(void* ptr, double x, double y)
{
	static_cast<QRadialGradient*>(ptr)->setFocalPoint(x, y);
}

void QRadialGradient_SetFocalRadius(void* ptr, double radius)
{
	static_cast<QRadialGradient*>(ptr)->setFocalRadius(radius);
}

void QRadialGradient_SetRadius(void* ptr, double radius)
{
	static_cast<QRadialGradient*>(ptr)->setRadius(radius);
}

void* QRadialGradient_Center(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QRadialGradient*>(ptr)->center(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QRadialGradient_FocalPoint(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QRadialGradient*>(ptr)->focalPoint(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

double QRadialGradient_CenterRadius(void* ptr)
{
	return static_cast<QRadialGradient*>(ptr)->centerRadius();
}

double QRadialGradient_FocalRadius(void* ptr)
{
	return static_cast<QRadialGradient*>(ptr)->focalRadius();
}

double QRadialGradient_Radius(void* ptr)
{
	return static_cast<QRadialGradient*>(ptr)->radius();
}

class MyQRasterWindow: public QRasterWindow
{
public:
	MyQRasterWindow(QWindow *parent) : QRasterWindow(parent) {};
	void paintEvent(QPaintEvent * event) { callbackQPaintDeviceWindow_PaintEvent(this, event); };
	void update() { callbackQPaintDeviceWindow_Update3(this); };
	bool close() { return callbackQWindow_Close(this) != 0; };
	bool event(QEvent * ev) { return callbackQWindow_Event(this, ev) != 0; };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWindow_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, *result) != 0; };
	void Signal_ActiveChanged() { callbackQWindow_ActiveChanged(this); };
	void alert(int msec) { callbackQWindow_Alert(this, msec); };
	void Signal_ContentOrientationChanged(Qt::ScreenOrientation orientation) { callbackQWindow_ContentOrientationChanged(this, orientation); };
	void exposeEvent(QExposeEvent * ev) { callbackQWindow_ExposeEvent(this, ev); };
	void focusInEvent(QFocusEvent * ev) { callbackQWindow_FocusInEvent(this, ev); };
	void Signal_FocusObjectChanged(QObject * object) { callbackQWindow_FocusObjectChanged(this, object); };
	void focusOutEvent(QFocusEvent * ev) { callbackQWindow_FocusOutEvent(this, ev); };
	void Signal_HeightChanged(int arg) { callbackQWindow_HeightChanged(this, arg); };
	void hide() { callbackQWindow_Hide(this); };
	void hideEvent(QHideEvent * ev) { callbackQWindow_HideEvent(this, ev); };
	void keyPressEvent(QKeyEvent * ev) { callbackQWindow_KeyPressEvent(this, ev); };
	void keyReleaseEvent(QKeyEvent * ev) { callbackQWindow_KeyReleaseEvent(this, ev); };
	void lower() { callbackQWindow_Lower(this); };
	void Signal_MaximumHeightChanged(int arg) { callbackQWindow_MaximumHeightChanged(this, arg); };
	void Signal_MaximumWidthChanged(int arg) { callbackQWindow_MaximumWidthChanged(this, arg); };
	void Signal_MinimumHeightChanged(int arg) { callbackQWindow_MinimumHeightChanged(this, arg); };
	void Signal_MinimumWidthChanged(int arg) { callbackQWindow_MinimumWidthChanged(this, arg); };
	void Signal_ModalityChanged(Qt::WindowModality modality) { callbackQWindow_ModalityChanged(this, modality); };
	void mouseDoubleClickEvent(QMouseEvent * ev) { callbackQWindow_MouseDoubleClickEvent(this, ev); };
	void mouseMoveEvent(QMouseEvent * ev) { callbackQWindow_MouseMoveEvent(this, ev); };
	void mousePressEvent(QMouseEvent * ev) { callbackQWindow_MousePressEvent(this, ev); };
	void mouseReleaseEvent(QMouseEvent * ev) { callbackQWindow_MouseReleaseEvent(this, ev); };
	void moveEvent(QMoveEvent * ev) { callbackQWindow_MoveEvent(this, ev); };
	void Signal_OpacityChanged(qreal opacity) { callbackQWindow_OpacityChanged(this, opacity); };
	void raise() { callbackQWindow_Raise(this); };
	void requestActivate() { callbackQWindow_RequestActivate(this); };
	void requestUpdate() { callbackQWindow_RequestUpdate(this); };
	void resizeEvent(QResizeEvent * ev) { callbackQWindow_ResizeEvent(this, ev); };
	void Signal_ScreenChanged(QScreen * screen) { callbackQWindow_ScreenChanged(this, screen); };
	void setHeight(int arg) { callbackQWindow_SetHeight(this, arg); };
	void setMaximumHeight(int h) { callbackQWindow_SetMaximumHeight(this, h); };
	void setMaximumWidth(int w) { callbackQWindow_SetMaximumWidth(this, w); };
	void setMinimumHeight(int h) { callbackQWindow_SetMinimumHeight(this, h); };
	void setMinimumWidth(int w) { callbackQWindow_SetMinimumWidth(this, w); };
	void setTitle(const QString & vqs) { QByteArray tda39a3 = vqs.toUtf8(); QtGui_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };callbackQWindow_SetTitle(this, vqsPacked); };
	void setVisible(bool visible) { callbackQWindow_SetVisible(this, visible); };
	void setWidth(int arg) { callbackQWindow_SetWidth(this, arg); };
	void setX(int arg) { callbackQWindow_SetX(this, arg); };
	void setY(int arg) { callbackQWindow_SetY(this, arg); };
	void show() { callbackQWindow_Show(this); };
	void showEvent(QShowEvent * ev) { callbackQWindow_ShowEvent(this, ev); };
	void showFullScreen() { callbackQWindow_ShowFullScreen(this); };
	void showMaximized() { callbackQWindow_ShowMaximized(this); };
	void showMinimized() { callbackQWindow_ShowMinimized(this); };
	void showNormal() { callbackQWindow_ShowNormal(this); };
	void tabletEvent(QTabletEvent * ev) { callbackQWindow_TabletEvent(this, ev); };
	void touchEvent(QTouchEvent * ev) { callbackQWindow_TouchEvent(this, ev); };
	void Signal_VisibilityChanged(QWindow::Visibility visibility) { callbackQWindow_VisibilityChanged(this, visibility); };
	void Signal_VisibleChanged(bool arg) { callbackQWindow_VisibleChanged(this, arg); };
	void wheelEvent(QWheelEvent * ev) { callbackQWindow_WheelEvent(this, ev); };
	void Signal_WidthChanged(int arg) { callbackQWindow_WidthChanged(this, arg); };
	void Signal_WindowStateChanged(Qt::WindowState windowState) { callbackQWindow_WindowStateChanged(this, windowState); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray t3c6de1 = title.toUtf8(); QtGui_PackedString titlePacked = { const_cast<char*>(t3c6de1.prepend("WHITESPACE").constData()+10), t3c6de1.size()-10 };callbackQWindow_WindowTitleChanged(this, titlePacked); };
	void Signal_XChanged(int arg) { callbackQWindow_XChanged(this, arg); };
	void Signal_YChanged(int arg) { callbackQWindow_YChanged(this, arg); };
	QObject * focusObject() const { return static_cast<QObject*>(callbackQWindow_FocusObject(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize size() const { return *static_cast<QSize*>(callbackQWindow_Size(const_cast<void*>(static_cast<const void*>(this)))); };
	QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQWindow_Format(const_cast<void*>(static_cast<const void*>(this)))); };
	SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQWindow_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWindow_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQWindow_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWindow_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWindow_CustomEvent(this, event); };
	void deleteLater() { callbackQWindow_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWindow_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWindow_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQWindow_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWindow_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWindow_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
	QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPaintDeviceWindow_PaintEngine(const_cast<void*>(static_cast<const void*>(this)))); };
	int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPaintDevice_Metric(const_cast<void*>(static_cast<const void*>(this)), metric); };
};

void* QRasterWindow_NewQRasterWindow(void* parent)
{
	return new MyQRasterWindow(static_cast<QWindow*>(parent));
}

void* QRawFont_QRawFont_FromFont(void* font, long long writingSystem)
{
	return new QRawFont(QRawFont::fromFont(*static_cast<QFont*>(font), static_cast<QFontDatabase::WritingSystem>(writingSystem)));
}

void* QRawFont_NewQRawFont()
{
	return new QRawFont();
}

void* QRawFont_NewQRawFont3(void* fontData, double pixelSize, long long hintingPreference)
{
	return new QRawFont(*static_cast<QByteArray*>(fontData), pixelSize, static_cast<QFont::HintingPreference>(hintingPreference));
}

void* QRawFont_NewQRawFont4(void* other)
{
	return new QRawFont(*static_cast<QRawFont*>(other));
}

void* QRawFont_NewQRawFont2(char* fileName, double pixelSize, long long hintingPreference)
{
	return new QRawFont(QString(fileName), pixelSize, static_cast<QFont::HintingPreference>(hintingPreference));
}

void QRawFont_LoadFromData(void* ptr, void* fontData, double pixelSize, long long hintingPreference)
{
	static_cast<QRawFont*>(ptr)->loadFromData(*static_cast<QByteArray*>(fontData), pixelSize, static_cast<QFont::HintingPreference>(hintingPreference));
}

void QRawFont_LoadFromFile(void* ptr, char* fileName, double pixelSize, long long hintingPreference)
{
	static_cast<QRawFont*>(ptr)->loadFromFile(QString(fileName), pixelSize, static_cast<QFont::HintingPreference>(hintingPreference));
}

void QRawFont_SetPixelSize(void* ptr, double pixelSize)
{
	static_cast<QRawFont*>(ptr)->setPixelSize(pixelSize);
}

void QRawFont_Swap(void* ptr, void* other)
{
	static_cast<QRawFont*>(ptr)->swap(*static_cast<QRawFont*>(other));
}

void QRawFont_DestroyQRawFont(void* ptr)
{
	static_cast<QRawFont*>(ptr)->~QRawFont();
}

void* QRawFont_FontTable(void* ptr, char* tagName)
{
	return new QByteArray(static_cast<QRawFont*>(ptr)->fontTable(const_cast<const char*>(tagName)));
}

long long QRawFont_HintingPreference(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->hintingPreference();
}

long long QRawFont_Style(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->style();
}

void* QRawFont_AlphaMapForGlyph(void* ptr, unsigned int glyphIndex, long long antialiasingType, void* transform)
{
	return new QImage(static_cast<QRawFont*>(ptr)->alphaMapForGlyph(glyphIndex, static_cast<QRawFont::AntialiasingType>(antialiasingType), *static_cast<QTransform*>(transform)));
}

struct QtGui_PackedList QRawFont_SupportedWritingSystems(void* ptr)
{
	return ({ QList<QFontDatabase::WritingSystem>* tmpValue = new QList<QFontDatabase::WritingSystem>(static_cast<QRawFont*>(ptr)->supportedWritingSystems()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QRawFont_PathForGlyph(void* ptr, unsigned int glyphIndex)
{
	return new QPainterPath(static_cast<QRawFont*>(ptr)->pathForGlyph(glyphIndex));
}

void* QRawFont_BoundingRect(void* ptr, unsigned int glyphIndex)
{
	return ({ QRectF tmpValue = static_cast<QRawFont*>(ptr)->boundingRect(glyphIndex); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QRawFont_FamilyName(void* ptr)
{
	return ({ QByteArray t8c920d = static_cast<QRawFont*>(ptr)->familyName().toUtf8(); QtGui_PackedString { const_cast<char*>(t8c920d.prepend("WHITESPACE").constData()+10), t8c920d.size()-10 }; });
}

struct QtGui_PackedString QRawFont_StyleName(void* ptr)
{
	return ({ QByteArray t6b9c52 = static_cast<QRawFont*>(ptr)->styleName().toUtf8(); QtGui_PackedString { const_cast<char*>(t6b9c52.prepend("WHITESPACE").constData()+10), t6b9c52.size()-10 }; });
}

struct QtGui_PackedList QRawFont_AdvancesForGlyphIndexes2(void* ptr, void* glyphIndexes)
{
	return ({ QVector<QPointF>* tmpValue = new QVector<QPointF>(static_cast<QRawFont*>(ptr)->advancesForGlyphIndexes(*static_cast<QVector<quint32>*>(glyphIndexes))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QRawFont_AdvancesForGlyphIndexes(void* ptr, void* glyphIndexes, long long layoutFlags)
{
	return ({ QVector<QPointF>* tmpValue = new QVector<QPointF>(static_cast<QRawFont*>(ptr)->advancesForGlyphIndexes(*static_cast<QVector<quint32>*>(glyphIndexes), static_cast<QRawFont::LayoutFlag>(layoutFlags))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QRawFont_GlyphIndexesForString(void* ptr, char* text)
{
	return ({ QVector<quint32>* tmpValue = new QVector<quint32>(static_cast<QRawFont*>(ptr)->glyphIndexesForString(QString(text))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

char QRawFont_AdvancesForGlyphIndexes3(void* ptr, unsigned int glyphIndexes, void* advances, int numGlyphs)
{
	return static_cast<QRawFont*>(ptr)->advancesForGlyphIndexes(const_cast<const quint32*>(&glyphIndexes), static_cast<QPointF*>(advances), numGlyphs);
}

char QRawFont_AdvancesForGlyphIndexes4(void* ptr, unsigned int glyphIndexes, void* advances, int numGlyphs, long long layoutFlags)
{
	return static_cast<QRawFont*>(ptr)->advancesForGlyphIndexes(const_cast<const quint32*>(&glyphIndexes), static_cast<QPointF*>(advances), numGlyphs, static_cast<QRawFont::LayoutFlag>(layoutFlags));
}

char QRawFont_GlyphIndexesForChars(void* ptr, void* chars, int numChars, unsigned int glyphIndexes, int numGlyphs)
{
	return static_cast<QRawFont*>(ptr)->glyphIndexesForChars(static_cast<QChar*>(chars), numChars, &glyphIndexes, &numGlyphs);
}

char QRawFont_IsValid(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->isValid();
}

char QRawFont_SupportsCharacter(void* ptr, void* character)
{
	return static_cast<QRawFont*>(ptr)->supportsCharacter(*static_cast<QChar*>(character));
}

char QRawFont_SupportsCharacter2(void* ptr, unsigned int ucs4)
{
	return static_cast<QRawFont*>(ptr)->supportsCharacter(ucs4);
}

int QRawFont_Weight(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->weight();
}

double QRawFont_Ascent(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->ascent();
}

double QRawFont_AverageCharWidth(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->averageCharWidth();
}

double QRawFont_CapHeight(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->capHeight();
}

double QRawFont_Descent(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->descent();
}

double QRawFont_Leading(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->leading();
}

double QRawFont_LineThickness(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->lineThickness();
}

double QRawFont_MaxCharWidth(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->maxCharWidth();
}

double QRawFont_PixelSize(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->pixelSize();
}

double QRawFont_UnderlinePosition(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->underlinePosition();
}

double QRawFont_UnitsPerEm(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->unitsPerEm();
}

double QRawFont_XHeight(void* ptr)
{
	return static_cast<QRawFont*>(ptr)->xHeight();
}

long long QRawFont___supportedWritingSystems_atList(void* ptr, int i)
{
	return static_cast<QList<QFontDatabase::WritingSystem>*>(ptr)->at(i);
}

void QRawFont___supportedWritingSystems_setList(void* ptr, long long i)
{
	static_cast<QList<QFontDatabase::WritingSystem>*>(ptr)->append(static_cast<QFontDatabase::WritingSystem>(i));
}

void* QRawFont___supportedWritingSystems_newList(void* ptr)
{
	return new QList<QFontDatabase::WritingSystem>;
}

void* QRawFont___advancesForGlyphIndexes_atList2(void* ptr, int i)
{
	return ({ QPointF tmpValue = static_cast<QVector<QPointF>*>(ptr)->at(i); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QRawFont___advancesForGlyphIndexes_setList2(void* ptr, void* i)
{
	static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}

void* QRawFont___advancesForGlyphIndexes_newList2(void* ptr)
{
	return new QVector<QPointF>;
}

unsigned int QRawFont___advancesForGlyphIndexes_glyphIndexes_atList2(void* ptr, int i)
{
	return static_cast<QVector<quint32>*>(ptr)->at(i);
}

void QRawFont___advancesForGlyphIndexes_glyphIndexes_setList2(void* ptr, unsigned int i)
{
	static_cast<QVector<quint32>*>(ptr)->append(i);
}

void* QRawFont___advancesForGlyphIndexes_glyphIndexes_newList2(void* ptr)
{
	return new QVector<quint32>;
}

void* QRawFont___advancesForGlyphIndexes_atList(void* ptr, int i)
{
	return ({ QPointF tmpValue = static_cast<QVector<QPointF>*>(ptr)->at(i); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QRawFont___advancesForGlyphIndexes_setList(void* ptr, void* i)
{
	static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}

void* QRawFont___advancesForGlyphIndexes_newList(void* ptr)
{
	return new QVector<QPointF>;
}

unsigned int QRawFont___advancesForGlyphIndexes_glyphIndexes_atList(void* ptr, int i)
{
	return static_cast<QVector<quint32>*>(ptr)->at(i);
}

void QRawFont___advancesForGlyphIndexes_glyphIndexes_setList(void* ptr, unsigned int i)
{
	static_cast<QVector<quint32>*>(ptr)->append(i);
}

void* QRawFont___advancesForGlyphIndexes_glyphIndexes_newList(void* ptr)
{
	return new QVector<quint32>;
}

unsigned int QRawFont___glyphIndexesForString_atList(void* ptr, int i)
{
	return static_cast<QVector<quint32>*>(ptr)->at(i);
}

void QRawFont___glyphIndexesForString_setList(void* ptr, unsigned int i)
{
	static_cast<QVector<quint32>*>(ptr)->append(i);
}

void* QRawFont___glyphIndexesForString_newList(void* ptr)
{
	return new QVector<quint32>;
}

class MyQRegExpValidator: public QRegExpValidator
{
public:
	MyQRegExpValidator(QObject *parent) : QRegExpValidator(parent) {};
	MyQRegExpValidator(const QRegExp &rx, QObject *parent) : QRegExpValidator(rx, parent) {};
	QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQRegExpValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
	void Signal_Changed() { callbackQValidator_Changed(this); };
	void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	bool event(QEvent * e) { return callbackQValidator_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQValidator_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQValidator_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQValidator_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQValidator_CustomEvent(this, event); };
	void deleteLater() { callbackQValidator_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQValidator_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQValidator_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQValidator_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQValidator_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQValidator_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QRegExpValidator_NewQRegExpValidator(void* parent)
{
	return new MyQRegExpValidator(static_cast<QObject*>(parent));
}

void* QRegExpValidator_NewQRegExpValidator2(void* rx, void* parent)
{
	return new MyQRegExpValidator(*static_cast<QRegExp*>(rx), static_cast<QObject*>(parent));
}

void QRegExpValidator_SetRegExp(void* ptr, void* rx)
{
	static_cast<QRegExpValidator*>(ptr)->setRegExp(*static_cast<QRegExp*>(rx));
}

void QRegExpValidator_DestroyQRegExpValidator(void* ptr)
{
	static_cast<QRegExpValidator*>(ptr)->~QRegExpValidator();
}

long long QRegExpValidator_Validate(void* ptr, char* input, int pos)
{
	return static_cast<QRegExpValidator*>(ptr)->validate(*(new QString(input)), pos);
}

long long QRegExpValidator_ValidateDefault(void* ptr, char* input, int pos)
{
		return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::validate(*(new QString(input)), pos);
}

void* QRegExpValidator_RegExp(void* ptr)
{
	return const_cast<QRegExp*>(&static_cast<QRegExpValidator*>(ptr)->regExp());
}

void* QRegion_NewQRegion()
{
	return new QRegion();
}

void* QRegion_NewQRegion6(void* other)
{
	return new QRegion(*static_cast<QRegion*>(other));
}

void* QRegion_NewQRegion7(void* bm)
{
	return new QRegion(*static_cast<QBitmap*>(bm));
}

void* QRegion_NewQRegion4(void* a, long long fillRule)
{
	return new QRegion(*static_cast<QPolygon*>(a), static_cast<Qt::FillRule>(fillRule));
}

void* QRegion_NewQRegion3(void* r, long long t)
{
	return new QRegion(*static_cast<QRect*>(r), static_cast<QRegion::RegionType>(t));
}

void* QRegion_NewQRegion5(void* r)
{
	return new QRegion(*static_cast<QRegion*>(r));
}

void* QRegion_NewQRegion2(int x, int y, int w, int h, long long t)
{
	return new QRegion(x, y, w, h, static_cast<QRegion::RegionType>(t));
}

void QRegion_SetRects(void* ptr, void* rects, int number)
{
	static_cast<QRegion*>(ptr)->setRects(static_cast<QRect*>(rects), number);
}

void QRegion_Swap(void* ptr, void* other)
{
	static_cast<QRegion*>(ptr)->swap(*static_cast<QRegion*>(other));
}

void QRegion_Translate2(void* ptr, void* point)
{
	static_cast<QRegion*>(ptr)->translate(*static_cast<QPoint*>(point));
}

void QRegion_Translate(void* ptr, int dx, int dy)
{
	static_cast<QRegion*>(ptr)->translate(dx, dy);
}

void* QRegion_BoundingRect(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QRegion*>(ptr)->boundingRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QRegion_Intersected2(void* ptr, void* rect)
{
	return new QRegion(static_cast<QRegion*>(ptr)->intersected(*static_cast<QRect*>(rect)));
}

void* QRegion_Intersected(void* ptr, void* r)
{
	return new QRegion(static_cast<QRegion*>(ptr)->intersected(*static_cast<QRegion*>(r)));
}

void* QRegion_Subtracted(void* ptr, void* r)
{
	return new QRegion(static_cast<QRegion*>(ptr)->subtracted(*static_cast<QRegion*>(r)));
}

void* QRegion_Translated2(void* ptr, void* p)
{
	return new QRegion(static_cast<QRegion*>(ptr)->translated(*static_cast<QPoint*>(p)));
}

void* QRegion_Translated(void* ptr, int dx, int dy)
{
	return new QRegion(static_cast<QRegion*>(ptr)->translated(dx, dy));
}

void* QRegion_United2(void* ptr, void* rect)
{
	return new QRegion(static_cast<QRegion*>(ptr)->united(*static_cast<QRect*>(rect)));
}

void* QRegion_United(void* ptr, void* r)
{
	return new QRegion(static_cast<QRegion*>(ptr)->united(*static_cast<QRegion*>(r)));
}

void* QRegion_Xored(void* ptr, void* r)
{
	return new QRegion(static_cast<QRegion*>(ptr)->xored(*static_cast<QRegion*>(r)));
}

struct QtGui_PackedList QRegion_Rects(void* ptr)
{
	return ({ QVector<QRect>* tmpValue = new QVector<QRect>(static_cast<QRegion*>(ptr)->rects()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

char QRegion_Contains(void* ptr, void* p)
{
	return static_cast<QRegion*>(ptr)->contains(*static_cast<QPoint*>(p));
}

char QRegion_Contains2(void* ptr, void* r)
{
	return static_cast<QRegion*>(ptr)->contains(*static_cast<QRect*>(r));
}

char QRegion_Intersects2(void* ptr, void* rect)
{
	return static_cast<QRegion*>(ptr)->intersects(*static_cast<QRect*>(rect));
}

char QRegion_Intersects(void* ptr, void* region)
{
	return static_cast<QRegion*>(ptr)->intersects(*static_cast<QRegion*>(region));
}

char QRegion_IsEmpty(void* ptr)
{
	return static_cast<QRegion*>(ptr)->isEmpty();
}

char QRegion_IsNull(void* ptr)
{
	return static_cast<QRegion*>(ptr)->isNull();
}

int QRegion_RectCount(void* ptr)
{
	return static_cast<QRegion*>(ptr)->rectCount();
}

void* QRegion___rects_atList(void* ptr, int i)
{
	return ({ QRect tmpValue = static_cast<QVector<QRect>*>(ptr)->at(i); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void QRegion___rects_setList(void* ptr, void* i)
{
	static_cast<QVector<QRect>*>(ptr)->append(*static_cast<QRect*>(i));
}

void* QRegion___rects_newList(void* ptr)
{
	return new QVector<QRect>;
}

class MyQRegularExpressionValidator: public QRegularExpressionValidator
{
public:
	MyQRegularExpressionValidator(QObject *parent) : QRegularExpressionValidator(parent) {};
	MyQRegularExpressionValidator(const QRegularExpression &re, QObject *parent) : QRegularExpressionValidator(re, parent) {};
	void Signal_RegularExpressionChanged(const QRegularExpression & re) { callbackQRegularExpressionValidator_RegularExpressionChanged(this, const_cast<QRegularExpression*>(&re)); };
	void setRegularExpression(const QRegularExpression & re) { callbackQRegularExpressionValidator_SetRegularExpression(this, const_cast<QRegularExpression*>(&re)); };
	QValidator::State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQRegularExpressionValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
	void Signal_Changed() { callbackQValidator_Changed(this); };
	void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	bool event(QEvent * e) { return callbackQValidator_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQValidator_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQValidator_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQValidator_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQValidator_CustomEvent(this, event); };
	void deleteLater() { callbackQValidator_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQValidator_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQValidator_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQValidator_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQValidator_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQValidator_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QRegularExpressionValidator_NewQRegularExpressionValidator(void* parent)
{
	return new MyQRegularExpressionValidator(static_cast<QObject*>(parent));
}

void* QRegularExpressionValidator_NewQRegularExpressionValidator2(void* re, void* parent)
{
	return new MyQRegularExpressionValidator(*static_cast<QRegularExpression*>(re), static_cast<QObject*>(parent));
}

void QRegularExpressionValidator_ConnectRegularExpressionChanged(void* ptr)
{
	QObject::connect(static_cast<QRegularExpressionValidator*>(ptr), static_cast<void (QRegularExpressionValidator::*)(const QRegularExpression &)>(&QRegularExpressionValidator::regularExpressionChanged), static_cast<MyQRegularExpressionValidator*>(ptr), static_cast<void (MyQRegularExpressionValidator::*)(const QRegularExpression &)>(&MyQRegularExpressionValidator::Signal_RegularExpressionChanged));
}

void QRegularExpressionValidator_DisconnectRegularExpressionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QRegularExpressionValidator*>(ptr), static_cast<void (QRegularExpressionValidator::*)(const QRegularExpression &)>(&QRegularExpressionValidator::regularExpressionChanged), static_cast<MyQRegularExpressionValidator*>(ptr), static_cast<void (MyQRegularExpressionValidator::*)(const QRegularExpression &)>(&MyQRegularExpressionValidator::Signal_RegularExpressionChanged));
}

void QRegularExpressionValidator_RegularExpressionChanged(void* ptr, void* re)
{
	static_cast<QRegularExpressionValidator*>(ptr)->regularExpressionChanged(*static_cast<QRegularExpression*>(re));
}

void QRegularExpressionValidator_SetRegularExpression(void* ptr, void* re)
{
	QMetaObject::invokeMethod(static_cast<QRegularExpressionValidator*>(ptr), "setRegularExpression", Q_ARG(QRegularExpression, *static_cast<QRegularExpression*>(re)));
}

void QRegularExpressionValidator_SetRegularExpressionDefault(void* ptr, void* re)
{
		static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::setRegularExpression(*static_cast<QRegularExpression*>(re));
}

void QRegularExpressionValidator_DestroyQRegularExpressionValidator(void* ptr)
{
	static_cast<QRegularExpressionValidator*>(ptr)->~QRegularExpressionValidator();
}

void* QRegularExpressionValidator_RegularExpression(void* ptr)
{
	return new QRegularExpression(static_cast<QRegularExpressionValidator*>(ptr)->regularExpression());
}

long long QRegularExpressionValidator_Validate(void* ptr, char* input, int pos)
{
	return static_cast<QRegularExpressionValidator*>(ptr)->validate(*(new QString(input)), pos);
}

long long QRegularExpressionValidator_ValidateDefault(void* ptr, char* input, int pos)
{
		return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::validate(*(new QString(input)), pos);
}

class MyQResizeEvent: public QResizeEvent
{
public:
	MyQResizeEvent(const QSize &size, const QSize &oldSize) : QResizeEvent(size, oldSize) {};
};

void* QResizeEvent_NewQResizeEvent(void* size, void* oldSize)
{
	return new MyQResizeEvent(*static_cast<QSize*>(size), *static_cast<QSize*>(oldSize));
}

void* QResizeEvent_OldSize(void* ptr)
{
	return const_cast<QSize*>(&static_cast<QResizeEvent*>(ptr)->oldSize());
}

void* QResizeEvent_Size(void* ptr)
{
	return const_cast<QSize*>(&static_cast<QResizeEvent*>(ptr)->size());
}

void QRgba64_SetAlpha(void* ptr, unsigned short alpha)
{
	static_cast<QRgba64*>(ptr)->setAlpha(alpha);
}

void QRgba64_SetBlue(void* ptr, unsigned short blue)
{
	static_cast<QRgba64*>(ptr)->setBlue(blue);
}

void QRgba64_SetGreen(void* ptr, unsigned short green)
{
	static_cast<QRgba64*>(ptr)->setGreen(green);
}

void QRgba64_SetRed(void* ptr, unsigned short red)
{
	static_cast<QRgba64*>(ptr)->setRed(red);
}

char QRgba64_IsOpaque(void* ptr)
{
	return static_cast<QRgba64*>(ptr)->isOpaque();
}

char QRgba64_IsTransparent(void* ptr)
{
	return static_cast<QRgba64*>(ptr)->isTransparent();
}

unsigned short QRgba64_Alpha(void* ptr)
{
	return static_cast<QRgba64*>(ptr)->alpha();
}

unsigned short QRgba64_Blue(void* ptr)
{
	return static_cast<QRgba64*>(ptr)->blue();
}

unsigned short QRgba64_Green(void* ptr)
{
	return static_cast<QRgba64*>(ptr)->green();
}

unsigned short QRgba64_Red(void* ptr)
{
	return static_cast<QRgba64*>(ptr)->red();
}

struct QtGui_PackedString QRgba64_Alpha8(void* ptr)
{
	return ({ quint8 pret13de7c = static_cast<QRgba64*>(ptr)->alpha8(); char* t13de7c = static_cast<char*>(static_cast<void*>(&pret13de7c)); QtGui_PackedString { t13de7c, -1 }; });
}

struct QtGui_PackedString QRgba64_Blue8(void* ptr)
{
	return ({ quint8 pret2116e7 = static_cast<QRgba64*>(ptr)->blue8(); char* t2116e7 = static_cast<char*>(static_cast<void*>(&pret2116e7)); QtGui_PackedString { t2116e7, -1 }; });
}

struct QtGui_PackedString QRgba64_Green8(void* ptr)
{
	return ({ quint8 pret72b7b3 = static_cast<QRgba64*>(ptr)->green8(); char* t72b7b3 = static_cast<char*>(static_cast<void*>(&pret72b7b3)); QtGui_PackedString { t72b7b3, -1 }; });
}

struct QtGui_PackedString QRgba64_Red8(void* ptr)
{
	return ({ quint8 pretd7bc71 = static_cast<QRgba64*>(ptr)->red8(); char* td7bc71 = static_cast<char*>(static_cast<void*>(&pretd7bc71)); QtGui_PackedString { td7bc71, -1 }; });
}

unsigned int QRgba64_ToArgb32(void* ptr)
{
	return static_cast<QRgba64*>(ptr)->toArgb32();
}

unsigned short QRgba64_ToRgb16(void* ptr)
{
	return static_cast<QRgba64*>(ptr)->toRgb16();
}

class MyQScreen: public QScreen
{
public:
	void Signal_AvailableGeometryChanged(const QRect & geometry) { callbackQScreen_AvailableGeometryChanged(this, const_cast<QRect*>(&geometry)); };
	void Signal_GeometryChanged(const QRect & geometry) { callbackQScreen_GeometryChanged(this, const_cast<QRect*>(&geometry)); };
	void Signal_LogicalDotsPerInchChanged(qreal dpi) { callbackQScreen_LogicalDotsPerInchChanged(this, dpi); };
	void Signal_OrientationChanged(Qt::ScreenOrientation orientation) { callbackQScreen_OrientationChanged(this, orientation); };
	void Signal_PhysicalDotsPerInchChanged(qreal dpi) { callbackQScreen_PhysicalDotsPerInchChanged(this, dpi); };
	void Signal_PhysicalSizeChanged(const QSizeF & size) { callbackQScreen_PhysicalSizeChanged(this, const_cast<QSizeF*>(&size)); };
	void Signal_PrimaryOrientationChanged(Qt::ScreenOrientation orientation) { callbackQScreen_PrimaryOrientationChanged(this, orientation); };
	void Signal_RefreshRateChanged(qreal refreshRate) { callbackQScreen_RefreshRateChanged(this, refreshRate); };
	void Signal_VirtualGeometryChanged(const QRect & rect) { callbackQScreen_VirtualGeometryChanged(this, const_cast<QRect*>(&rect)); };
	bool event(QEvent * e) { return callbackQScreen_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQScreen_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQScreen_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQScreen_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQScreen_CustomEvent(this, event); };
	void deleteLater() { callbackQScreen_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQScreen_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQScreen_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQScreen_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQScreen_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQScreen_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QScreen_GrabWindow(void* ptr, uintptr_t window, int x, int y, int width, int height)
{
	return new QPixmap(static_cast<QScreen*>(ptr)->grabWindow(window, x, y, width, height));
}

void QScreen_ConnectAvailableGeometryChanged(void* ptr)
{
	QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::availableGeometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_AvailableGeometryChanged));
}

void QScreen_DisconnectAvailableGeometryChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::availableGeometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_AvailableGeometryChanged));
}

void QScreen_AvailableGeometryChanged(void* ptr, void* geometry)
{
	static_cast<QScreen*>(ptr)->availableGeometryChanged(*static_cast<QRect*>(geometry));
}

void QScreen_ConnectGeometryChanged(void* ptr)
{
	QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::geometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_GeometryChanged));
}

void QScreen_DisconnectGeometryChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::geometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_GeometryChanged));
}

void QScreen_GeometryChanged(void* ptr, void* geometry)
{
	static_cast<QScreen*>(ptr)->geometryChanged(*static_cast<QRect*>(geometry));
}

void QScreen_ConnectLogicalDotsPerInchChanged(void* ptr)
{
	QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::logicalDotsPerInchChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_LogicalDotsPerInchChanged));
}

void QScreen_DisconnectLogicalDotsPerInchChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::logicalDotsPerInchChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_LogicalDotsPerInchChanged));
}

void QScreen_LogicalDotsPerInchChanged(void* ptr, double dpi)
{
	static_cast<QScreen*>(ptr)->logicalDotsPerInchChanged(dpi);
}

void QScreen_ConnectOrientationChanged(void* ptr)
{
	QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(Qt::ScreenOrientation)>(&QScreen::orientationChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(Qt::ScreenOrientation)>(&MyQScreen::Signal_OrientationChanged));
}

void QScreen_DisconnectOrientationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(Qt::ScreenOrientation)>(&QScreen::orientationChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(Qt::ScreenOrientation)>(&MyQScreen::Signal_OrientationChanged));
}

void QScreen_OrientationChanged(void* ptr, long long orientation)
{
	static_cast<QScreen*>(ptr)->orientationChanged(static_cast<Qt::ScreenOrientation>(orientation));
}

void QScreen_ConnectPhysicalDotsPerInchChanged(void* ptr)
{
	QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::physicalDotsPerInchChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_PhysicalDotsPerInchChanged));
}

void QScreen_DisconnectPhysicalDotsPerInchChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::physicalDotsPerInchChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_PhysicalDotsPerInchChanged));
}

void QScreen_PhysicalDotsPerInchChanged(void* ptr, double dpi)
{
	static_cast<QScreen*>(ptr)->physicalDotsPerInchChanged(dpi);
}

void QScreen_ConnectPhysicalSizeChanged(void* ptr)
{
	QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QSizeF &)>(&QScreen::physicalSizeChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QSizeF &)>(&MyQScreen::Signal_PhysicalSizeChanged));
}

void QScreen_DisconnectPhysicalSizeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QSizeF &)>(&QScreen::physicalSizeChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QSizeF &)>(&MyQScreen::Signal_PhysicalSizeChanged));
}

void QScreen_PhysicalSizeChanged(void* ptr, void* size)
{
	static_cast<QScreen*>(ptr)->physicalSizeChanged(*static_cast<QSizeF*>(size));
}

void QScreen_ConnectPrimaryOrientationChanged(void* ptr)
{
	QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(Qt::ScreenOrientation)>(&QScreen::primaryOrientationChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(Qt::ScreenOrientation)>(&MyQScreen::Signal_PrimaryOrientationChanged));
}

void QScreen_DisconnectPrimaryOrientationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(Qt::ScreenOrientation)>(&QScreen::primaryOrientationChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(Qt::ScreenOrientation)>(&MyQScreen::Signal_PrimaryOrientationChanged));
}

void QScreen_PrimaryOrientationChanged(void* ptr, long long orientation)
{
	static_cast<QScreen*>(ptr)->primaryOrientationChanged(static_cast<Qt::ScreenOrientation>(orientation));
}

void QScreen_ConnectRefreshRateChanged(void* ptr)
{
	QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::refreshRateChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_RefreshRateChanged));
}

void QScreen_DisconnectRefreshRateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(qreal)>(&QScreen::refreshRateChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(qreal)>(&MyQScreen::Signal_RefreshRateChanged));
}

void QScreen_RefreshRateChanged(void* ptr, double refreshRate)
{
	static_cast<QScreen*>(ptr)->refreshRateChanged(refreshRate);
}

void QScreen_SetOrientationUpdateMask(void* ptr, long long mask)
{
	static_cast<QScreen*>(ptr)->setOrientationUpdateMask(static_cast<Qt::ScreenOrientation>(mask));
}

void QScreen_ConnectVirtualGeometryChanged(void* ptr)
{
	QObject::connect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::virtualGeometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_VirtualGeometryChanged));
}

void QScreen_DisconnectVirtualGeometryChanged(void* ptr)
{
	QObject::disconnect(static_cast<QScreen*>(ptr), static_cast<void (QScreen::*)(const QRect &)>(&QScreen::virtualGeometryChanged), static_cast<MyQScreen*>(ptr), static_cast<void (MyQScreen::*)(const QRect &)>(&MyQScreen::Signal_VirtualGeometryChanged));
}

void QScreen_VirtualGeometryChanged(void* ptr, void* rect)
{
	static_cast<QScreen*>(ptr)->virtualGeometryChanged(*static_cast<QRect*>(rect));
}

void QScreen_DestroyQScreen(void* ptr)
{
	static_cast<QScreen*>(ptr)->~QScreen();
}

struct QtGui_PackedList QScreen_VirtualSiblings(void* ptr)
{
	return ({ QList<QScreen *>* tmpValue = new QList<QScreen *>(static_cast<QScreen*>(ptr)->virtualSiblings()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QScreen_AvailableGeometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QScreen*>(ptr)->availableGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QScreen_AvailableVirtualGeometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QScreen*>(ptr)->availableVirtualGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QScreen_Geometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QScreen*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QScreen_MapBetween(void* ptr, long long a, long long b, void* rect)
{
	return ({ QRect tmpValue = static_cast<QScreen*>(ptr)->mapBetween(static_cast<Qt::ScreenOrientation>(a), static_cast<Qt::ScreenOrientation>(b), *static_cast<QRect*>(rect)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QScreen_VirtualGeometry(void* ptr)
{
	return ({ QRect tmpValue = static_cast<QScreen*>(ptr)->virtualGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QScreen_AvailableSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScreen*>(ptr)->availableSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScreen_AvailableVirtualSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScreen*>(ptr)->availableVirtualSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScreen_Size(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScreen*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScreen_VirtualSize(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QScreen*>(ptr)->virtualSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QScreen_PhysicalSize(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QScreen*>(ptr)->physicalSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QScreen_Name(void* ptr)
{
	return ({ QByteArray tc60f02 = static_cast<QScreen*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(tc60f02.prepend("WHITESPACE").constData()+10), tc60f02.size()-10 }; });
}

void* QScreen_TransformBetween(void* ptr, long long a, long long b, void* target)
{
	return new QTransform(static_cast<QScreen*>(ptr)->transformBetween(static_cast<Qt::ScreenOrientation>(a), static_cast<Qt::ScreenOrientation>(b), *static_cast<QRect*>(target)));
}

long long QScreen_NativeOrientation(void* ptr)
{
	return static_cast<QScreen*>(ptr)->nativeOrientation();
}

long long QScreen_Orientation(void* ptr)
{
	return static_cast<QScreen*>(ptr)->orientation();
}

long long QScreen_PrimaryOrientation(void* ptr)
{
	return static_cast<QScreen*>(ptr)->primaryOrientation();
}

long long QScreen_OrientationUpdateMask(void* ptr)
{
	return static_cast<QScreen*>(ptr)->orientationUpdateMask();
}

char QScreen_IsLandscape(void* ptr, long long o)
{
	return static_cast<QScreen*>(ptr)->isLandscape(static_cast<Qt::ScreenOrientation>(o));
}

char QScreen_IsPortrait(void* ptr, long long o)
{
	return static_cast<QScreen*>(ptr)->isPortrait(static_cast<Qt::ScreenOrientation>(o));
}

int QScreen_AngleBetween(void* ptr, long long a, long long b)
{
	return static_cast<QScreen*>(ptr)->angleBetween(static_cast<Qt::ScreenOrientation>(a), static_cast<Qt::ScreenOrientation>(b));
}

int QScreen_Depth(void* ptr)
{
	return static_cast<QScreen*>(ptr)->depth();
}

double QScreen_DevicePixelRatio(void* ptr)
{
	return static_cast<QScreen*>(ptr)->devicePixelRatio();
}

double QScreen_LogicalDotsPerInch(void* ptr)
{
	return static_cast<QScreen*>(ptr)->logicalDotsPerInch();
}

double QScreen_LogicalDotsPerInchX(void* ptr)
{
	return static_cast<QScreen*>(ptr)->logicalDotsPerInchX();
}

double QScreen_LogicalDotsPerInchY(void* ptr)
{
	return static_cast<QScreen*>(ptr)->logicalDotsPerInchY();
}

double QScreen_PhysicalDotsPerInch(void* ptr)
{
	return static_cast<QScreen*>(ptr)->physicalDotsPerInch();
}

double QScreen_PhysicalDotsPerInchX(void* ptr)
{
	return static_cast<QScreen*>(ptr)->physicalDotsPerInchX();
}

double QScreen_PhysicalDotsPerInchY(void* ptr)
{
	return static_cast<QScreen*>(ptr)->physicalDotsPerInchY();
}

double QScreen_RefreshRate(void* ptr)
{
	return static_cast<QScreen*>(ptr)->refreshRate();
}

void* QScreen___virtualSiblings_atList(void* ptr, int i)
{
	return const_cast<QScreen*>(static_cast<QList<QScreen *>*>(ptr)->at(i));
}

void QScreen___virtualSiblings_setList(void* ptr, void* i)
{
	static_cast<QList<QScreen *>*>(ptr)->append(static_cast<QScreen*>(i));
}

void* QScreen___virtualSiblings_newList(void* ptr)
{
	return new QList<QScreen *>;
}

void* QScreen___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QScreen___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QScreen___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QScreen___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QScreen___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QScreen___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QScreen___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QScreen___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QScreen___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QScreen___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QScreen___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QScreen___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QScreen___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QScreen___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QScreen___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QScreen_EventDefault(void* ptr, void* e)
{
		return static_cast<QScreen*>(ptr)->QScreen::event(static_cast<QEvent*>(e));
}

char QScreen_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QScreen*>(ptr)->QScreen::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QScreen*>(ptr)->QScreen::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QScreen*>(ptr)->QScreen::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QScreen*>(ptr)->QScreen::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QScreen*>(ptr)->QScreen::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QScreen_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QScreen*>(ptr)->QScreen::childEvent(static_cast<QChildEvent*>(event));
}

void QScreen_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QScreen*>(ptr)->QScreen::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScreen_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QScreen*>(ptr)->QScreen::customEvent(static_cast<QEvent*>(event));
}

void QScreen_DeleteLaterDefault(void* ptr)
{
		static_cast<QScreen*>(ptr)->QScreen::deleteLater();
}

void QScreen_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QScreen*>(ptr)->QScreen::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QScreen_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QScreen*>(ptr)->QScreen::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QScreen_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QScreen*>(ptr)->QScreen::metaObject());
}

class MyQScrollEvent: public QScrollEvent
{
public:
	MyQScrollEvent(const QPointF &contentPos, const QPointF &overshootDistance, ScrollState scrollState) : QScrollEvent(contentPos, overshootDistance, scrollState) {};
};

void* QScrollEvent_NewQScrollEvent(void* contentPos, void* overshootDistance, long long scrollState)
{
	return new MyQScrollEvent(*static_cast<QPointF*>(contentPos), *static_cast<QPointF*>(overshootDistance), static_cast<QScrollEvent::ScrollState>(scrollState));
}

void QScrollEvent_DestroyQScrollEvent(void* ptr)
{
	static_cast<QScrollEvent*>(ptr)->~QScrollEvent();
}

void* QScrollEvent_ContentPos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QScrollEvent*>(ptr)->contentPos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QScrollEvent_OvershootDistance(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QScrollEvent*>(ptr)->overshootDistance(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

long long QScrollEvent_ScrollState(void* ptr)
{
	return static_cast<QScrollEvent*>(ptr)->scrollState();
}

class MyQScrollPrepareEvent: public QScrollPrepareEvent
{
public:
	MyQScrollPrepareEvent(const QPointF &startPos) : QScrollPrepareEvent(startPos) {};
};

void* QScrollPrepareEvent_NewQScrollPrepareEvent(void* startPos)
{
	return new MyQScrollPrepareEvent(*static_cast<QPointF*>(startPos));
}

void QScrollPrepareEvent_SetContentPos(void* ptr, void* pos)
{
	static_cast<QScrollPrepareEvent*>(ptr)->setContentPos(*static_cast<QPointF*>(pos));
}

void QScrollPrepareEvent_SetContentPosRange(void* ptr, void* rect)
{
	static_cast<QScrollPrepareEvent*>(ptr)->setContentPosRange(*static_cast<QRectF*>(rect));
}

void QScrollPrepareEvent_SetViewportSize(void* ptr, void* size)
{
	static_cast<QScrollPrepareEvent*>(ptr)->setViewportSize(*static_cast<QSizeF*>(size));
}

void QScrollPrepareEvent_DestroyQScrollPrepareEvent(void* ptr)
{
	static_cast<QScrollPrepareEvent*>(ptr)->~QScrollPrepareEvent();
}

void* QScrollPrepareEvent_ContentPos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QScrollPrepareEvent*>(ptr)->contentPos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QScrollPrepareEvent_StartPos(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QScrollPrepareEvent*>(ptr)->startPos(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QScrollPrepareEvent_ContentPosRange(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QScrollPrepareEvent*>(ptr)->contentPosRange(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QScrollPrepareEvent_ViewportSize(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QScrollPrepareEvent*>(ptr)->viewportSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

class MyQSessionManager: public QSessionManager
{
public:
	bool event(QEvent * e) { return callbackQSessionManager_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSessionManager_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQSessionManager_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSessionManager_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSessionManager_CustomEvent(this, event); };
	void deleteLater() { callbackQSessionManager_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQSessionManager_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSessionManager_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQSessionManager_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQSessionManager_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSessionManager_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

char QSessionManager_AllowsErrorInteraction(void* ptr)
{
	return static_cast<QSessionManager*>(ptr)->allowsErrorInteraction();
}

char QSessionManager_AllowsInteraction(void* ptr)
{
	return static_cast<QSessionManager*>(ptr)->allowsInteraction();
}

void QSessionManager_Cancel(void* ptr)
{
	static_cast<QSessionManager*>(ptr)->cancel();
}

void QSessionManager_Release(void* ptr)
{
	static_cast<QSessionManager*>(ptr)->release();
}

void QSessionManager_RequestPhase2(void* ptr)
{
	static_cast<QSessionManager*>(ptr)->requestPhase2();
}

void QSessionManager_SetDiscardCommand(void* ptr, char* command)
{
	static_cast<QSessionManager*>(ptr)->setDiscardCommand(QString(command).split("|", QString::SkipEmptyParts));
}

void QSessionManager_SetManagerProperty2(void* ptr, char* name, char* value)
{
	static_cast<QSessionManager*>(ptr)->setManagerProperty(QString(name), QString(value));
}

void QSessionManager_SetManagerProperty(void* ptr, char* name, char* value)
{
	static_cast<QSessionManager*>(ptr)->setManagerProperty(QString(name), QString(value).split("|", QString::SkipEmptyParts));
}

void QSessionManager_SetRestartCommand(void* ptr, char* command)
{
	static_cast<QSessionManager*>(ptr)->setRestartCommand(QString(command).split("|", QString::SkipEmptyParts));
}

void QSessionManager_SetRestartHint(void* ptr, long long hint)
{
	static_cast<QSessionManager*>(ptr)->setRestartHint(static_cast<QSessionManager::RestartHint>(hint));
}

struct QtGui_PackedString QSessionManager_SessionId(void* ptr)
{
	return ({ QByteArray t8eaf8d = static_cast<QSessionManager*>(ptr)->sessionId().toUtf8(); QtGui_PackedString { const_cast<char*>(t8eaf8d.prepend("WHITESPACE").constData()+10), t8eaf8d.size()-10 }; });
}

struct QtGui_PackedString QSessionManager_SessionKey(void* ptr)
{
	return ({ QByteArray tb1e419 = static_cast<QSessionManager*>(ptr)->sessionKey().toUtf8(); QtGui_PackedString { const_cast<char*>(tb1e419.prepend("WHITESPACE").constData()+10), tb1e419.size()-10 }; });
}

struct QtGui_PackedString QSessionManager_DiscardCommand(void* ptr)
{
	return ({ QByteArray t7ed2e8 = static_cast<QSessionManager*>(ptr)->discardCommand().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t7ed2e8.prepend("WHITESPACE").constData()+10), t7ed2e8.size()-10 }; });
}

struct QtGui_PackedString QSessionManager_RestartCommand(void* ptr)
{
	return ({ QByteArray t8b3c52 = static_cast<QSessionManager*>(ptr)->restartCommand().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t8b3c52.prepend("WHITESPACE").constData()+10), t8b3c52.size()-10 }; });
}

long long QSessionManager_RestartHint(void* ptr)
{
	return static_cast<QSessionManager*>(ptr)->restartHint();
}

char QSessionManager_IsPhase2(void* ptr)
{
	return static_cast<QSessionManager*>(ptr)->isPhase2();
}

void* QSessionManager___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QSessionManager___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QSessionManager___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QSessionManager___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSessionManager___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSessionManager___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QSessionManager___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSessionManager___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSessionManager___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QSessionManager___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSessionManager___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSessionManager___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QSessionManager___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QSessionManager___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSessionManager___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QSessionManager_EventDefault(void* ptr, void* e)
{
		return static_cast<QSessionManager*>(ptr)->QSessionManager::event(static_cast<QEvent*>(e));
}

char QSessionManager_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QSessionManager*>(ptr)->QSessionManager::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QSessionManager*>(ptr)->QSessionManager::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QSessionManager*>(ptr)->QSessionManager::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QSessionManager*>(ptr)->QSessionManager::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QSessionManager*>(ptr)->QSessionManager::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QSessionManager_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QSessionManager*>(ptr)->QSessionManager::childEvent(static_cast<QChildEvent*>(event));
}

void QSessionManager_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QSessionManager*>(ptr)->QSessionManager::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSessionManager_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QSessionManager*>(ptr)->QSessionManager::customEvent(static_cast<QEvent*>(event));
}

void QSessionManager_DeleteLaterDefault(void* ptr)
{
		static_cast<QSessionManager*>(ptr)->QSessionManager::deleteLater();
}

void QSessionManager_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QSessionManager*>(ptr)->QSessionManager::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSessionManager_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QSessionManager*>(ptr)->QSessionManager::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QSessionManager_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QSessionManager*>(ptr)->QSessionManager::metaObject());
}

class MyQShortcutEvent: public QShortcutEvent
{
public:
	MyQShortcutEvent(const QKeySequence &key, int id, bool ambiguous) : QShortcutEvent(key, id, ambiguous) {};
};

void* QShortcutEvent_NewQShortcutEvent(void* key, int id, char ambiguous)
{
	return new MyQShortcutEvent(*static_cast<QKeySequence*>(key), id, ambiguous != 0);
}

void QShortcutEvent_DestroyQShortcutEvent(void* ptr)
{
	static_cast<QShortcutEvent*>(ptr)->~QShortcutEvent();
}

char QShortcutEvent_IsAmbiguous(void* ptr)
{
	return static_cast<QShortcutEvent*>(ptr)->isAmbiguous();
}

void* QShortcutEvent_Key(void* ptr)
{
	return const_cast<QKeySequence*>(&static_cast<QShortcutEvent*>(ptr)->key());
}

int QShortcutEvent_ShortcutId(void* ptr)
{
	return static_cast<QShortcutEvent*>(ptr)->shortcutId();
}

char QShortcutEvent_Ambig(void* ptr)
{
	return static_cast<QShortcutEvent*>(ptr)->ambig;
}

void QShortcutEvent_SetAmbig(void* ptr, char vbo)
{
	static_cast<QShortcutEvent*>(ptr)->ambig = vbo != 0;
}

void* QShortcutEvent_Sequence(void* ptr)
{
	return new QKeySequence(static_cast<QShortcutEvent*>(ptr)->sequence);
}

void QShortcutEvent_SetSequence(void* ptr, void* vqk)
{
	static_cast<QShortcutEvent*>(ptr)->sequence = *static_cast<QKeySequence*>(vqk);
}

int QShortcutEvent_Sid(void* ptr)
{
	return static_cast<QShortcutEvent*>(ptr)->sid;
}

void QShortcutEvent_SetSid(void* ptr, int vin)
{
	static_cast<QShortcutEvent*>(ptr)->sid = vin;
}

class MyQShowEvent: public QShowEvent
{
public:
	MyQShowEvent() : QShowEvent() {};
};

void* QShowEvent_NewQShowEvent()
{
	return new MyQShowEvent();
}

class MyQStandardItem: public QStandardItem
{
public:
	MyQStandardItem() : QStandardItem() {};
	MyQStandardItem(const QIcon &icon, const QString &text) : QStandardItem(icon, text) {};
	MyQStandardItem(const QStandardItem &other) : QStandardItem(other) {};
	MyQStandardItem(const QString &text) : QStandardItem(text) {};
	MyQStandardItem(int rows, int columns) : QStandardItem(rows, columns) {};
	void read(QDataStream & in) { callbackQStandardItem_Read(this, static_cast<QDataStream*>(&in)); };
	void setData(const QVariant & value, int role) { callbackQStandardItem_SetData(this, const_cast<QVariant*>(&value), role); };
	 ~MyQStandardItem() { callbackQStandardItem_DestroyQStandardItem(this); };
	QStandardItem * clone() const { return static_cast<QStandardItem*>(callbackQStandardItem_Clone(const_cast<void*>(static_cast<const void*>(this)))); };
	QVariant data(int role) const { return *static_cast<QVariant*>(callbackQStandardItem_Data(const_cast<void*>(static_cast<const void*>(this)), role)); };
	int type() const { return callbackQStandardItem_Type(const_cast<void*>(static_cast<const void*>(this))); };
	void write(QDataStream & out) const { callbackQStandardItem_Write(const_cast<void*>(static_cast<const void*>(this)), static_cast<QDataStream*>(&out)); };
};

struct QtGui_PackedList QStandardItem_TakeColumn(void* ptr, int column)
{
	return ({ QList<QStandardItem *>* tmpValue = new QList<QStandardItem *>(static_cast<QStandardItem*>(ptr)->takeColumn(column)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QStandardItem_TakeRow(void* ptr, int row)
{
	return ({ QList<QStandardItem *>* tmpValue = new QList<QStandardItem *>(static_cast<QStandardItem*>(ptr)->takeRow(row)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QStandardItem_TakeChild(void* ptr, int row, int column)
{
	return static_cast<QStandardItem*>(ptr)->takeChild(row, column);
}

void* QStandardItem_NewQStandardItem()
{
	return new MyQStandardItem();
}

void* QStandardItem_NewQStandardItem3(void* icon, char* text)
{
	return new MyQStandardItem(*static_cast<QIcon*>(icon), QString(text));
}

void* QStandardItem_NewQStandardItem5(void* other)
{
	return new MyQStandardItem(*static_cast<QStandardItem*>(other));
}

void* QStandardItem_NewQStandardItem2(char* text)
{
	return new MyQStandardItem(QString(text));
}

void* QStandardItem_NewQStandardItem4(int rows, int columns)
{
	return new MyQStandardItem(rows, columns);
}

void QStandardItem_AppendColumn(void* ptr, void* items)
{
	static_cast<QStandardItem*>(ptr)->appendColumn(*static_cast<QList<QStandardItem *>*>(items));
}

void QStandardItem_AppendRow2(void* ptr, void* item)
{
	static_cast<QStandardItem*>(ptr)->appendRow(static_cast<QStandardItem*>(item));
}

void QStandardItem_AppendRow(void* ptr, void* items)
{
	static_cast<QStandardItem*>(ptr)->appendRow(*static_cast<QList<QStandardItem *>*>(items));
}

void QStandardItem_AppendRows(void* ptr, void* items)
{
	static_cast<QStandardItem*>(ptr)->appendRows(*static_cast<QList<QStandardItem *>*>(items));
}

void QStandardItem_EmitDataChanged(void* ptr)
{
	static_cast<QStandardItem*>(ptr)->emitDataChanged();
}

void QStandardItem_InsertColumn(void* ptr, int column, void* items)
{
	static_cast<QStandardItem*>(ptr)->insertColumn(column, *static_cast<QList<QStandardItem *>*>(items));
}

void QStandardItem_InsertColumns(void* ptr, int column, int count)
{
	static_cast<QStandardItem*>(ptr)->insertColumns(column, count);
}

void QStandardItem_InsertRow2(void* ptr, int row, void* item)
{
	static_cast<QStandardItem*>(ptr)->insertRow(row, static_cast<QStandardItem*>(item));
}

void QStandardItem_InsertRow(void* ptr, int row, void* items)
{
	static_cast<QStandardItem*>(ptr)->insertRow(row, *static_cast<QList<QStandardItem *>*>(items));
}

void QStandardItem_InsertRows(void* ptr, int row, void* items)
{
	static_cast<QStandardItem*>(ptr)->insertRows(row, *static_cast<QList<QStandardItem *>*>(items));
}

void QStandardItem_InsertRows2(void* ptr, int row, int count)
{
	static_cast<QStandardItem*>(ptr)->insertRows(row, count);
}

void QStandardItem_Read(void* ptr, void* in)
{
	static_cast<QStandardItem*>(ptr)->read(*static_cast<QDataStream*>(in));
}

void QStandardItem_ReadDefault(void* ptr, void* in)
{
		static_cast<QStandardItem*>(ptr)->QStandardItem::read(*static_cast<QDataStream*>(in));
}

void QStandardItem_RemoveColumn(void* ptr, int column)
{
	static_cast<QStandardItem*>(ptr)->removeColumn(column);
}

void QStandardItem_RemoveColumns(void* ptr, int column, int count)
{
	static_cast<QStandardItem*>(ptr)->removeColumns(column, count);
}

void QStandardItem_RemoveRow(void* ptr, int row)
{
	static_cast<QStandardItem*>(ptr)->removeRow(row);
}

void QStandardItem_RemoveRows(void* ptr, int row, int count)
{
	static_cast<QStandardItem*>(ptr)->removeRows(row, count);
}

void QStandardItem_SetAccessibleDescription(void* ptr, char* accessibleDescription)
{
	static_cast<QStandardItem*>(ptr)->setAccessibleDescription(QString(accessibleDescription));
}

void QStandardItem_SetAccessibleText(void* ptr, char* accessibleText)
{
	static_cast<QStandardItem*>(ptr)->setAccessibleText(QString(accessibleText));
}

void QStandardItem_SetAutoTristate(void* ptr, char tristate)
{
	static_cast<QStandardItem*>(ptr)->setAutoTristate(tristate != 0);
}

void QStandardItem_SetBackground(void* ptr, void* brush)
{
	static_cast<QStandardItem*>(ptr)->setBackground(*static_cast<QBrush*>(brush));
}

void QStandardItem_SetCheckState(void* ptr, long long state)
{
	static_cast<QStandardItem*>(ptr)->setCheckState(static_cast<Qt::CheckState>(state));
}

void QStandardItem_SetCheckable(void* ptr, char checkable)
{
	static_cast<QStandardItem*>(ptr)->setCheckable(checkable != 0);
}

void QStandardItem_SetChild2(void* ptr, int row, void* item)
{
	static_cast<QStandardItem*>(ptr)->setChild(row, static_cast<QStandardItem*>(item));
}

void QStandardItem_SetChild(void* ptr, int row, int column, void* item)
{
	static_cast<QStandardItem*>(ptr)->setChild(row, column, static_cast<QStandardItem*>(item));
}

void QStandardItem_SetColumnCount(void* ptr, int columns)
{
	static_cast<QStandardItem*>(ptr)->setColumnCount(columns);
}

void QStandardItem_SetData(void* ptr, void* value, int role)
{
	static_cast<QStandardItem*>(ptr)->setData(*static_cast<QVariant*>(value), role);
}

void QStandardItem_SetDataDefault(void* ptr, void* value, int role)
{
		static_cast<QStandardItem*>(ptr)->QStandardItem::setData(*static_cast<QVariant*>(value), role);
}

void QStandardItem_SetDragEnabled(void* ptr, char dragEnabled)
{
	static_cast<QStandardItem*>(ptr)->setDragEnabled(dragEnabled != 0);
}

void QStandardItem_SetDropEnabled(void* ptr, char dropEnabled)
{
	static_cast<QStandardItem*>(ptr)->setDropEnabled(dropEnabled != 0);
}

void QStandardItem_SetEditable(void* ptr, char editable)
{
	static_cast<QStandardItem*>(ptr)->setEditable(editable != 0);
}

void QStandardItem_SetEnabled(void* ptr, char enabled)
{
	static_cast<QStandardItem*>(ptr)->setEnabled(enabled != 0);
}

void QStandardItem_SetFlags(void* ptr, long long flags)
{
	static_cast<QStandardItem*>(ptr)->setFlags(static_cast<Qt::ItemFlag>(flags));
}

void QStandardItem_SetFont(void* ptr, void* font)
{
	static_cast<QStandardItem*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QStandardItem_SetForeground(void* ptr, void* brush)
{
	static_cast<QStandardItem*>(ptr)->setForeground(*static_cast<QBrush*>(brush));
}

void QStandardItem_SetIcon(void* ptr, void* icon)
{
	static_cast<QStandardItem*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
}

void QStandardItem_SetRowCount(void* ptr, int rows)
{
	static_cast<QStandardItem*>(ptr)->setRowCount(rows);
}

void QStandardItem_SetSelectable(void* ptr, char selectable)
{
	static_cast<QStandardItem*>(ptr)->setSelectable(selectable != 0);
}

void QStandardItem_SetSizeHint(void* ptr, void* size)
{
	static_cast<QStandardItem*>(ptr)->setSizeHint(*static_cast<QSize*>(size));
}

void QStandardItem_SetStatusTip(void* ptr, char* statusTip)
{
	static_cast<QStandardItem*>(ptr)->setStatusTip(QString(statusTip));
}

void QStandardItem_SetText(void* ptr, char* text)
{
	static_cast<QStandardItem*>(ptr)->setText(QString(text));
}

void QStandardItem_SetTextAlignment(void* ptr, long long alignment)
{
	static_cast<QStandardItem*>(ptr)->setTextAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QStandardItem_SetToolTip(void* ptr, char* toolTip)
{
	static_cast<QStandardItem*>(ptr)->setToolTip(QString(toolTip));
}

void QStandardItem_SetUserTristate(void* ptr, char tristate)
{
	static_cast<QStandardItem*>(ptr)->setUserTristate(tristate != 0);
}

void QStandardItem_SetWhatsThis(void* ptr, char* whatsThis)
{
	static_cast<QStandardItem*>(ptr)->setWhatsThis(QString(whatsThis));
}

void QStandardItem_SortChildren(void* ptr, int column, long long order)
{
	static_cast<QStandardItem*>(ptr)->sortChildren(column, static_cast<Qt::SortOrder>(order));
}

void QStandardItem_DestroyQStandardItem(void* ptr)
{
	static_cast<QStandardItem*>(ptr)->~QStandardItem();
}

void QStandardItem_DestroyQStandardItemDefault(void* ptr)
{

}

void* QStandardItem_Background(void* ptr)
{
	return new QBrush(static_cast<QStandardItem*>(ptr)->background());
}

void* QStandardItem_Foreground(void* ptr)
{
	return new QBrush(static_cast<QStandardItem*>(ptr)->foreground());
}

void* QStandardItem_Font(void* ptr)
{
	return new QFont(static_cast<QStandardItem*>(ptr)->font());
}

void* QStandardItem_Icon(void* ptr)
{
	return new QIcon(static_cast<QStandardItem*>(ptr)->icon());
}

void* QStandardItem_Index(void* ptr)
{
	return new QModelIndex(static_cast<QStandardItem*>(ptr)->index());
}

void* QStandardItem_SizeHint(void* ptr)
{
	return ({ QSize tmpValue = static_cast<QStandardItem*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}

void* QStandardItem_Child(void* ptr, int row, int column)
{
	return static_cast<QStandardItem*>(ptr)->child(row, column);
}

void* QStandardItem_Clone(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->clone();
}

void* QStandardItem_CloneDefault(void* ptr)
{
		return static_cast<QStandardItem*>(ptr)->QStandardItem::clone();
}

void* QStandardItem_Parent(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->parent();
}

void* QStandardItem_Model(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->model();
}

struct QtGui_PackedString QStandardItem_AccessibleDescription(void* ptr)
{
	return ({ QByteArray t03d242 = static_cast<QStandardItem*>(ptr)->accessibleDescription().toUtf8(); QtGui_PackedString { const_cast<char*>(t03d242.prepend("WHITESPACE").constData()+10), t03d242.size()-10 }; });
}

struct QtGui_PackedString QStandardItem_AccessibleText(void* ptr)
{
	return ({ QByteArray t3ec2e5 = static_cast<QStandardItem*>(ptr)->accessibleText().toUtf8(); QtGui_PackedString { const_cast<char*>(t3ec2e5.prepend("WHITESPACE").constData()+10), t3ec2e5.size()-10 }; });
}

struct QtGui_PackedString QStandardItem_StatusTip(void* ptr)
{
	return ({ QByteArray t534fca = static_cast<QStandardItem*>(ptr)->statusTip().toUtf8(); QtGui_PackedString { const_cast<char*>(t534fca.prepend("WHITESPACE").constData()+10), t534fca.size()-10 }; });
}

struct QtGui_PackedString QStandardItem_Text(void* ptr)
{
	return ({ QByteArray t847a7a = static_cast<QStandardItem*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(t847a7a.prepend("WHITESPACE").constData()+10), t847a7a.size()-10 }; });
}

struct QtGui_PackedString QStandardItem_ToolTip(void* ptr)
{
	return ({ QByteArray t938860 = static_cast<QStandardItem*>(ptr)->toolTip().toUtf8(); QtGui_PackedString { const_cast<char*>(t938860.prepend("WHITESPACE").constData()+10), t938860.size()-10 }; });
}

struct QtGui_PackedString QStandardItem_WhatsThis(void* ptr)
{
	return ({ QByteArray taa28dd = static_cast<QStandardItem*>(ptr)->whatsThis().toUtf8(); QtGui_PackedString { const_cast<char*>(taa28dd.prepend("WHITESPACE").constData()+10), taa28dd.size()-10 }; });
}

void* QStandardItem_Data(void* ptr, int role)
{
	return new QVariant(static_cast<QStandardItem*>(ptr)->data(role));
}

void* QStandardItem_DataDefault(void* ptr, int role)
{
		return new QVariant(static_cast<QStandardItem*>(ptr)->QStandardItem::data(role));
}

long long QStandardItem_TextAlignment(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->textAlignment();
}

long long QStandardItem_CheckState(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->checkState();
}

long long QStandardItem_Flags(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->flags();
}

char QStandardItem_HasChildren(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->hasChildren();
}

char QStandardItem_IsAutoTristate(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->isAutoTristate();
}

char QStandardItem_IsCheckable(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->isCheckable();
}

char QStandardItem_IsDragEnabled(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->isDragEnabled();
}

char QStandardItem_IsDropEnabled(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->isDropEnabled();
}

char QStandardItem_IsEditable(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->isEditable();
}

char QStandardItem_IsEnabled(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->isEnabled();
}

char QStandardItem_IsSelectable(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->isSelectable();
}

char QStandardItem_IsUserTristate(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->isUserTristate();
}

int QStandardItem_Column(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->column();
}

int QStandardItem_ColumnCount(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->columnCount();
}

int QStandardItem_Row(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->row();
}

int QStandardItem_RowCount(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->rowCount();
}

int QStandardItem_Type(void* ptr)
{
	return static_cast<QStandardItem*>(ptr)->type();
}

int QStandardItem_TypeDefault(void* ptr)
{
		return static_cast<QStandardItem*>(ptr)->QStandardItem::type();
}

void QStandardItem_Write(void* ptr, void* out)
{
	static_cast<QStandardItem*>(ptr)->write(*static_cast<QDataStream*>(out));
}

void QStandardItem_WriteDefault(void* ptr, void* out)
{
		static_cast<QStandardItem*>(ptr)->QStandardItem::write(*static_cast<QDataStream*>(out));
}

void* QStandardItem___takeColumn_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItem___takeColumn_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItem___takeColumn_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItem___takeRow_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItem___takeRow_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItem___takeRow_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItem___appendColumn_items_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItem___appendColumn_items_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItem___appendColumn_items_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItem___appendRow_items_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItem___appendRow_items_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItem___appendRow_items_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItem___appendRows_items_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItem___appendRows_items_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItem___appendRows_items_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItem___insertColumn_items_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItem___insertColumn_items_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItem___insertColumn_items_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItem___insertRow_items_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItem___insertRow_items_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItem___insertRow_items_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItem___insertRows_items_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItem___insertRows_items_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItem___insertRows_items_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

class MyQStandardItemModel: public QStandardItemModel
{
public:
	MyQStandardItemModel(QObject *parent) : QStandardItemModel(parent) {};
	MyQStandardItemModel(int rows, int columns, QObject *parent) : QStandardItemModel(rows, columns, parent) {};
	bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQStandardItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
	bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQStandardItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
	bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQStandardItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
	bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQStandardItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
	bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQStandardItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
	bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQStandardItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
	bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQStandardItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
	bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQStandardItemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue = const_cast<QMap<int, QVariant>*>(&roles); QtGui_PackedList { tmpValue, tmpValue->size() }; })) != 0; };
	void Signal_ItemChanged(QStandardItem * item) { callbackQStandardItemModel_ItemChanged(this, item); };
	void sort(int column, Qt::SortOrder order) { callbackQStandardItemModel_Sort(this, column, order); };
	QMap<int, QVariant> itemData(const QModelIndex & index) const { return *static_cast<QMap<int, QVariant>*>(callbackQStandardItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQStandardItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(indexes); QtGui_PackedList { tmpValue, tmpValue->size() }; }))); };
	QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQStandardItemModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
	QModelIndex parent(const QModelIndex & child) const { return *static_cast<QModelIndex*>(callbackQStandardItemModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&child))); };
	QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQStandardItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
	QStringList mimeTypes() const { return QString(callbackQStandardItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this)))).split("|", QString::SkipEmptyParts); };
	QVariant data(const QModelIndex & index, int role) const { return *static_cast<QVariant*>(callbackQStandardItemModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), role)); };
	QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQStandardItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
	Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQStandardItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
	Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQStandardItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	bool hasChildren(const QModelIndex & parent) const { return callbackQStandardItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
	int columnCount(const QModelIndex & parent) const { return callbackQStandardItemModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
	int rowCount(const QModelIndex & parent) const { return callbackQStandardItemModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
	bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQStandardItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
	bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQStandardItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
	bool submit() { return callbackQStandardItemModel_Submit(this) != 0; };
	void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQStandardItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
	void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQStandardItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
	void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQStandardItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue = const_cast<QVector<int>*>(&roles); QtGui_PackedList { tmpValue, tmpValue->size() }; })); };
	void fetchMore(const QModelIndex & parent) { callbackQStandardItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
	void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQStandardItemModel_HeaderDataChanged(this, orientation, first, last); };
	void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQStandardItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValue = const_cast<QList<QPersistentModelIndex>*>(&parents); QtGui_PackedList { tmpValue, tmpValue->size() }; }), hint); };
	void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQStandardItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValue = const_cast<QList<QPersistentModelIndex>*>(&parents); QtGui_PackedList { tmpValue, tmpValue->size() }; }), hint); };
	void Signal_ModelAboutToBeReset() { callbackQStandardItemModel_ModelAboutToBeReset(this); };
	void Signal_ModelReset() { callbackQStandardItemModel_ModelReset(this); };
	void resetInternalData() { callbackQStandardItemModel_ResetInternalData(this); };
	void revert() { callbackQStandardItemModel_Revert(this); };
	void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQStandardItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
	void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQStandardItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
	void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
	void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQStandardItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
	void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQStandardItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
	QHash<int, QByteArray> roleNames() const { return *static_cast<QHash<int, QByteArray>*>(callbackQStandardItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); };
	QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQStandardItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return *static_cast<QList<QModelIndex>*>(callbackQStandardItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); };
	QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQStandardItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
	Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQStandardItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
	bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQStandardItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
	bool canFetchMore(const QModelIndex & parent) const { return callbackQStandardItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
	bool event(QEvent * e) { return callbackQStandardItemModel_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQStandardItemModel_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQStandardItemModel_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQStandardItemModel_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQStandardItemModel_CustomEvent(this, event); };
	void deleteLater() { callbackQStandardItemModel_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQStandardItemModel_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQStandardItemModel_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQStandardItemModel_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQStandardItemModel_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStandardItemModel_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

struct QtGui_PackedList QStandardItemModel_TakeColumn(void* ptr, int column)
{
	return ({ QList<QStandardItem *>* tmpValue = new QList<QStandardItem *>(static_cast<QStandardItemModel*>(ptr)->takeColumn(column)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QStandardItemModel_TakeRow(void* ptr, int row)
{
	return ({ QList<QStandardItem *>* tmpValue = new QList<QStandardItem *>(static_cast<QStandardItemModel*>(ptr)->takeRow(row)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QStandardItemModel_TakeHorizontalHeaderItem(void* ptr, int column)
{
	return static_cast<QStandardItemModel*>(ptr)->takeHorizontalHeaderItem(column);
}

void* QStandardItemModel_TakeItem(void* ptr, int row, int column)
{
	return static_cast<QStandardItemModel*>(ptr)->takeItem(row, column);
}

void* QStandardItemModel_TakeVerticalHeaderItem(void* ptr, int row)
{
	return static_cast<QStandardItemModel*>(ptr)->takeVerticalHeaderItem(row);
}

void* QStandardItemModel_NewQStandardItemModel(void* parent)
{
	return new MyQStandardItemModel(static_cast<QObject*>(parent));
}

void* QStandardItemModel_NewQStandardItemModel2(int rows, int columns, void* parent)
{
	return new MyQStandardItemModel(rows, columns, static_cast<QObject*>(parent));
}

char QStandardItemModel_DropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}

char QStandardItemModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}

char QStandardItemModel_InsertRowsDefault(void* ptr, int row, int count, void* parent)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
}

char QStandardItemModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
}

char QStandardItemModel_RemoveRowsDefault(void* ptr, int row, int count, void* parent)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
}

char QStandardItemModel_SetDataDefault(void* ptr, void* index, void* value, int role)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
}

char QStandardItemModel_SetHeaderDataDefault(void* ptr, int section, long long orientation, void* value, int role)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}

char QStandardItemModel_SetItemDataDefault(void* ptr, void* index, void* roles)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
}

void QStandardItemModel_AppendColumn(void* ptr, void* items)
{
	static_cast<QStandardItemModel*>(ptr)->appendColumn(*static_cast<QList<QStandardItem *>*>(items));
}

void QStandardItemModel_AppendRow2(void* ptr, void* item)
{
	static_cast<QStandardItemModel*>(ptr)->appendRow(static_cast<QStandardItem*>(item));
}

void QStandardItemModel_AppendRow(void* ptr, void* items)
{
	static_cast<QStandardItemModel*>(ptr)->appendRow(*static_cast<QList<QStandardItem *>*>(items));
}

void QStandardItemModel_Clear(void* ptr)
{
	static_cast<QStandardItemModel*>(ptr)->clear();
}

void QStandardItemModel_InsertColumn(void* ptr, int column, void* items)
{
	static_cast<QStandardItemModel*>(ptr)->insertColumn(column, *static_cast<QList<QStandardItem *>*>(items));
}

void QStandardItemModel_InsertRow2(void* ptr, int row, void* item)
{
	static_cast<QStandardItemModel*>(ptr)->insertRow(row, static_cast<QStandardItem*>(item));
}

void QStandardItemModel_InsertRow(void* ptr, int row, void* items)
{
	static_cast<QStandardItemModel*>(ptr)->insertRow(row, *static_cast<QList<QStandardItem *>*>(items));
}

void QStandardItemModel_ConnectItemChanged(void* ptr)
{
	QObject::connect(static_cast<QStandardItemModel*>(ptr), static_cast<void (QStandardItemModel::*)(QStandardItem *)>(&QStandardItemModel::itemChanged), static_cast<MyQStandardItemModel*>(ptr), static_cast<void (MyQStandardItemModel::*)(QStandardItem *)>(&MyQStandardItemModel::Signal_ItemChanged));
}

void QStandardItemModel_DisconnectItemChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStandardItemModel*>(ptr), static_cast<void (QStandardItemModel::*)(QStandardItem *)>(&QStandardItemModel::itemChanged), static_cast<MyQStandardItemModel*>(ptr), static_cast<void (MyQStandardItemModel::*)(QStandardItem *)>(&MyQStandardItemModel::Signal_ItemChanged));
}

void QStandardItemModel_ItemChanged(void* ptr, void* item)
{
	static_cast<QStandardItemModel*>(ptr)->itemChanged(static_cast<QStandardItem*>(item));
}

void QStandardItemModel_SetColumnCount(void* ptr, int columns)
{
	static_cast<QStandardItemModel*>(ptr)->setColumnCount(columns);
}

void QStandardItemModel_SetHorizontalHeaderItem(void* ptr, int column, void* item)
{
	static_cast<QStandardItemModel*>(ptr)->setHorizontalHeaderItem(column, static_cast<QStandardItem*>(item));
}

void QStandardItemModel_SetHorizontalHeaderLabels(void* ptr, char* labels)
{
	static_cast<QStandardItemModel*>(ptr)->setHorizontalHeaderLabels(QString(labels).split("|", QString::SkipEmptyParts));
}

void QStandardItemModel_SetItem2(void* ptr, int row, void* item)
{
	static_cast<QStandardItemModel*>(ptr)->setItem(row, static_cast<QStandardItem*>(item));
}

void QStandardItemModel_SetItem(void* ptr, int row, int column, void* item)
{
	static_cast<QStandardItemModel*>(ptr)->setItem(row, column, static_cast<QStandardItem*>(item));
}

void QStandardItemModel_SetItemPrototype(void* ptr, void* item)
{
	static_cast<QStandardItemModel*>(ptr)->setItemPrototype(static_cast<QStandardItem*>(item));
}

void QStandardItemModel_SetItemRoleNames(void* ptr, void* roleNames)
{
	static_cast<QStandardItemModel*>(ptr)->setItemRoleNames(*static_cast<QHash<int, QByteArray>*>(roleNames));
}

void QStandardItemModel_SetRowCount(void* ptr, int rows)
{
	static_cast<QStandardItemModel*>(ptr)->setRowCount(rows);
}

void QStandardItemModel_SetSortRole(void* ptr, int role)
{
	static_cast<QStandardItemModel*>(ptr)->setSortRole(role);
}

void QStandardItemModel_SetVerticalHeaderItem(void* ptr, int row, void* item)
{
	static_cast<QStandardItemModel*>(ptr)->setVerticalHeaderItem(row, static_cast<QStandardItem*>(item));
}

void QStandardItemModel_SetVerticalHeaderLabels(void* ptr, char* labels)
{
	static_cast<QStandardItemModel*>(ptr)->setVerticalHeaderLabels(QString(labels).split("|", QString::SkipEmptyParts));
}

void QStandardItemModel_SortDefault(void* ptr, int column, long long order)
{
		static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::sort(column, static_cast<Qt::SortOrder>(order));
}

void QStandardItemModel_DestroyQStandardItemModel(void* ptr)
{
	static_cast<QStandardItemModel*>(ptr)->~QStandardItemModel();
}

struct QtGui_PackedList QStandardItemModel_FindItems(void* ptr, char* text, long long flags, int column)
{
	return ({ QList<QStandardItem *>* tmpValue = new QList<QStandardItem *>(static_cast<QStandardItemModel*>(ptr)->findItems(QString(text), static_cast<Qt::MatchFlag>(flags), column)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedList QStandardItemModel_ItemDataDefault(void* ptr, void* index)
{
		return ({ QMap<int, QVariant>* tmpValue = new QMap<int, QVariant>(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::itemData(*static_cast<QModelIndex*>(index))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QStandardItemModel_MimeDataDefault(void* ptr, void* indexes)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::mimeData(*static_cast<QList<QModelIndex>*>(indexes));
}

void* QStandardItemModel_Index(void* ptr, int row, int column, void* parent)
{
	return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}

void* QStandardItemModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
		return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::index(row, column, *static_cast<QModelIndex*>(parent)));
}

void* QStandardItemModel_IndexFromItem(void* ptr, void* item)
{
	return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->indexFromItem(static_cast<QStandardItem*>(item)));
}

void* QStandardItemModel_Parent(void* ptr, void* child)
{
	return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->parent(*static_cast<QModelIndex*>(child)));
}

void* QStandardItemModel_ParentDefault(void* ptr, void* child)
{
		return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::parent(*static_cast<QModelIndex*>(child)));
}

void* QStandardItemModel_SiblingDefault(void* ptr, int row, int column, void* idx)
{
		return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::sibling(row, column, *static_cast<QModelIndex*>(idx)));
}

void* QStandardItemModel_HorizontalHeaderItem(void* ptr, int column)
{
	return static_cast<QStandardItemModel*>(ptr)->horizontalHeaderItem(column);
}

void* QStandardItemModel_InvisibleRootItem(void* ptr)
{
	return static_cast<QStandardItemModel*>(ptr)->invisibleRootItem();
}

void* QStandardItemModel_Item(void* ptr, int row, int column)
{
	return static_cast<QStandardItemModel*>(ptr)->item(row, column);
}

void* QStandardItemModel_ItemFromIndex(void* ptr, void* index)
{
	return static_cast<QStandardItemModel*>(ptr)->itemFromIndex(*static_cast<QModelIndex*>(index));
}

void* QStandardItemModel_VerticalHeaderItem(void* ptr, int row)
{
	return static_cast<QStandardItemModel*>(ptr)->verticalHeaderItem(row);
}

struct QtGui_PackedString QStandardItemModel_MimeTypesDefault(void* ptr)
{
		return ({ QByteArray t83a37d = static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::mimeTypes().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t83a37d.prepend("WHITESPACE").constData()+10), t83a37d.size()-10 }; });
}

void* QStandardItemModel_Data(void* ptr, void* index, int role)
{
	return new QVariant(static_cast<QStandardItemModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
}

void* QStandardItemModel_DataDefault(void* ptr, void* index, int role)
{
		return new QVariant(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::data(*static_cast<QModelIndex*>(index), role));
}

void* QStandardItemModel_HeaderDataDefault(void* ptr, int section, long long orientation, int role)
{
		return new QVariant(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
}

long long QStandardItemModel_SupportedDropActionsDefault(void* ptr)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::supportedDropActions();
}

long long QStandardItemModel_FlagsDefault(void* ptr, void* index)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::flags(*static_cast<QModelIndex*>(index));
}

char QStandardItemModel_HasChildrenDefault(void* ptr, void* parent)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::hasChildren(*static_cast<QModelIndex*>(parent));
}

void* QStandardItemModel_ItemPrototype(void* ptr)
{
	return const_cast<QStandardItem*>(static_cast<QStandardItemModel*>(ptr)->itemPrototype());
}

int QStandardItemModel_ColumnCount(void* ptr, void* parent)
{
	return static_cast<QStandardItemModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}

int QStandardItemModel_ColumnCountDefault(void* ptr, void* parent)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::columnCount(*static_cast<QModelIndex*>(parent));
}

int QStandardItemModel_RowCount(void* ptr, void* parent)
{
	return static_cast<QStandardItemModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}

int QStandardItemModel_RowCountDefault(void* ptr, void* parent)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::rowCount(*static_cast<QModelIndex*>(parent));
}

int QStandardItemModel_SortRole(void* ptr)
{
	return static_cast<QStandardItemModel*>(ptr)->sortRole();
}

void* QStandardItemModel___takeColumn_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItemModel___takeColumn_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItemModel___takeColumn_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItemModel___takeRow_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItemModel___takeRow_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItemModel___takeRow_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItemModel___setItemData_roles_atList(void* ptr, int i)
{
	return new QVariant(static_cast<QMap<int, QVariant>*>(ptr)->value(i));
}

void QStandardItemModel___setItemData_roles_setList(void* ptr, int key, void* i)
{
	static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}

void* QStandardItemModel___setItemData_roles_newList(void* ptr)
{
	return new QMap<int, QVariant>;
}

struct QtGui_PackedList QStandardItemModel___setItemData_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QStandardItemModel___appendColumn_items_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItemModel___appendColumn_items_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItemModel___appendColumn_items_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItemModel___appendRow_items_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItemModel___appendRow_items_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItemModel___appendRow_items_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItemModel___insertColumn_items_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItemModel___insertColumn_items_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItemModel___insertColumn_items_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItemModel___insertRow_items_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItemModel___insertRow_items_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItemModel___insertRow_items_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItemModel___setItemRoleNames_roleNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QHash<int, QByteArray>*>(ptr)->value(i));
}

void QStandardItemModel___setItemRoleNames_roleNames_setList(void* ptr, int key, void* i)
{
	static_cast<QHash<int, QByteArray>*>(ptr)->insert(key, *static_cast<QByteArray*>(i));
}

void* QStandardItemModel___setItemRoleNames_roleNames_newList(void* ptr)
{
	return new QHash<int, QByteArray>;
}

struct QtGui_PackedList QStandardItemModel___setItemRoleNames_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue = new QList<int>(static_cast<QHash<int, QByteArray>*>(ptr)->keys()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QStandardItemModel___findItems_atList(void* ptr, int i)
{
	return const_cast<QStandardItem*>(static_cast<QList<QStandardItem *>*>(ptr)->at(i));
}

void QStandardItemModel___findItems_setList(void* ptr, void* i)
{
	static_cast<QList<QStandardItem *>*>(ptr)->append(static_cast<QStandardItem*>(i));
}

void* QStandardItemModel___findItems_newList(void* ptr)
{
	return new QList<QStandardItem *>;
}

void* QStandardItemModel___itemData_atList(void* ptr, int i)
{
	return new QVariant(static_cast<QMap<int, QVariant>*>(ptr)->value(i));
}

void QStandardItemModel___itemData_setList(void* ptr, int key, void* i)
{
	static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}

void* QStandardItemModel___itemData_newList(void* ptr)
{
	return new QMap<int, QVariant>;
}

struct QtGui_PackedList QStandardItemModel___itemData_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QStandardItemModel___mimeData_indexes_atList(void* ptr, int i)
{
	return new QModelIndex(static_cast<QList<QModelIndex>*>(ptr)->at(i));
}

void QStandardItemModel___mimeData_indexes_setList(void* ptr, void* i)
{
	static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}

void* QStandardItemModel___mimeData_indexes_newList(void* ptr)
{
	return new QList<QModelIndex>;
}

int QStandardItemModel_____setItemData_keyList_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QStandardItemModel_____setItemData_keyList_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QStandardItemModel_____setItemData_keyList_newList(void* ptr)
{
	return new QList<int>;
}

int QStandardItemModel_____setItemRoleNames_keyList_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QStandardItemModel_____setItemRoleNames_keyList_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QStandardItemModel_____setItemRoleNames_keyList_newList(void* ptr)
{
	return new QList<int>;
}

int QStandardItemModel_____itemData_keyList_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QStandardItemModel_____itemData_keyList_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QStandardItemModel_____itemData_keyList_newList(void* ptr)
{
	return new QList<int>;
}

void* QStandardItemModel___changePersistentIndexList_from_atList(void* ptr, int i)
{
	return new QModelIndex(static_cast<QList<QModelIndex>*>(ptr)->at(i));
}

void QStandardItemModel___changePersistentIndexList_from_setList(void* ptr, void* i)
{
	static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}

void* QStandardItemModel___changePersistentIndexList_from_newList(void* ptr)
{
	return new QList<QModelIndex>;
}

void* QStandardItemModel___changePersistentIndexList_to_atList(void* ptr, int i)
{
	return new QModelIndex(static_cast<QList<QModelIndex>*>(ptr)->at(i));
}

void QStandardItemModel___changePersistentIndexList_to_setList(void* ptr, void* i)
{
	static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}

void* QStandardItemModel___changePersistentIndexList_to_newList(void* ptr)
{
	return new QList<QModelIndex>;
}

int QStandardItemModel___dataChanged_roles_atList(void* ptr, int i)
{
	return static_cast<QVector<int>*>(ptr)->at(i);
}

void QStandardItemModel___dataChanged_roles_setList(void* ptr, int i)
{
	static_cast<QVector<int>*>(ptr)->append(i);
}

void* QStandardItemModel___dataChanged_roles_newList(void* ptr)
{
	return new QVector<int>;
}

void* QStandardItemModel___layoutAboutToBeChanged_parents_atList(void* ptr, int i)
{
	return new QPersistentModelIndex(static_cast<QList<QPersistentModelIndex>*>(ptr)->at(i));
}

void QStandardItemModel___layoutAboutToBeChanged_parents_setList(void* ptr, void* i)
{
	static_cast<QList<QPersistentModelIndex>*>(ptr)->append(*static_cast<QPersistentModelIndex*>(i));
}

void* QStandardItemModel___layoutAboutToBeChanged_parents_newList(void* ptr)
{
	return new QList<QPersistentModelIndex>;
}

void* QStandardItemModel___layoutChanged_parents_atList(void* ptr, int i)
{
	return new QPersistentModelIndex(static_cast<QList<QPersistentModelIndex>*>(ptr)->at(i));
}

void QStandardItemModel___layoutChanged_parents_setList(void* ptr, void* i)
{
	static_cast<QList<QPersistentModelIndex>*>(ptr)->append(*static_cast<QPersistentModelIndex*>(i));
}

void* QStandardItemModel___layoutChanged_parents_newList(void* ptr)
{
	return new QList<QPersistentModelIndex>;
}

void* QStandardItemModel___roleNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QHash<int, QByteArray>*>(ptr)->value(i));
}

void QStandardItemModel___roleNames_setList(void* ptr, int key, void* i)
{
	static_cast<QHash<int, QByteArray>*>(ptr)->insert(key, *static_cast<QByteArray*>(i));
}

void* QStandardItemModel___roleNames_newList(void* ptr)
{
	return new QHash<int, QByteArray>;
}

struct QtGui_PackedList QStandardItemModel___roleNames_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue = new QList<int>(static_cast<QHash<int, QByteArray>*>(ptr)->keys()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QStandardItemModel___match_atList(void* ptr, int i)
{
	return new QModelIndex(static_cast<QList<QModelIndex>*>(ptr)->at(i));
}

void QStandardItemModel___match_setList(void* ptr, void* i)
{
	static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}

void* QStandardItemModel___match_newList(void* ptr)
{
	return new QList<QModelIndex>;
}

void* QStandardItemModel___persistentIndexList_atList(void* ptr, int i)
{
	return new QModelIndex(static_cast<QList<QModelIndex>*>(ptr)->at(i));
}

void QStandardItemModel___persistentIndexList_setList(void* ptr, void* i)
{
	static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}

void* QStandardItemModel___persistentIndexList_newList(void* ptr)
{
	return new QList<QModelIndex>;
}

int QStandardItemModel_____doSetRoleNames_keyList_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QStandardItemModel_____doSetRoleNames_keyList_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QStandardItemModel_____doSetRoleNames_keyList_newList(void* ptr)
{
	return new QList<int>;
}

int QStandardItemModel_____setRoleNames_keyList_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QStandardItemModel_____setRoleNames_keyList_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QStandardItemModel_____setRoleNames_keyList_newList(void* ptr)
{
	return new QList<int>;
}

int QStandardItemModel_____roleNames_keyList_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QStandardItemModel_____roleNames_keyList_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QStandardItemModel_____roleNames_keyList_newList(void* ptr)
{
	return new QList<int>;
}

void* QStandardItemModel___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QStandardItemModel___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QStandardItemModel___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QStandardItemModel___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QStandardItemModel___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QStandardItemModel___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QStandardItemModel___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QStandardItemModel___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QStandardItemModel___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QStandardItemModel___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QStandardItemModel___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QStandardItemModel___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QStandardItemModel___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QStandardItemModel___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QStandardItemModel___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QStandardItemModel_MoveColumnsDefault(void* ptr, void* sourceParent, int sourceColumn, int count, void* destinationParent, int destinationChild)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}

char QStandardItemModel_MoveRowsDefault(void* ptr, void* sourceParent, int sourceRow, int count, void* destinationParent, int destinationChild)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}

char QStandardItemModel_SubmitDefault(void* ptr)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::submit();
}

void QStandardItemModel_FetchMoreDefault(void* ptr, void* parent)
{
		static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::fetchMore(*static_cast<QModelIndex*>(parent));
}

void QStandardItemModel_ResetInternalDataDefault(void* ptr)
{
		static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::resetInternalData();
}

void QStandardItemModel_RevertDefault(void* ptr)
{
		static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::revert();
}

struct QtGui_PackedList QStandardItemModel_RoleNamesDefault(void* ptr)
{
		return ({ QHash<int, QByteArray>* tmpValue = new QHash<int, QByteArray>(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::roleNames()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QStandardItemModel_BuddyDefault(void* ptr, void* index)
{
		return new QModelIndex(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::buddy(*static_cast<QModelIndex*>(index)));
}

struct QtGui_PackedList QStandardItemModel_MatchDefault(void* ptr, void* start, int role, void* value, int hits, long long flags)
{
		return ({ QList<QModelIndex>* tmpValue = new QList<QModelIndex>(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QStandardItemModel_SpanDefault(void* ptr, void* index)
{
		return ({ QSize tmpValue = static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}

long long QStandardItemModel_SupportedDragActionsDefault(void* ptr)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::supportedDragActions();
}

char QStandardItemModel_CanDropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}

char QStandardItemModel_CanFetchMoreDefault(void* ptr, void* parent)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::canFetchMore(*static_cast<QModelIndex*>(parent));
}

char QStandardItemModel_EventDefault(void* ptr, void* e)
{
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::event(static_cast<QEvent*>(e));
}

char QStandardItemModel_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QStandardItemModel_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::childEvent(static_cast<QChildEvent*>(event));
}

void QStandardItemModel_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStandardItemModel_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::customEvent(static_cast<QEvent*>(event));
}

void QStandardItemModel_DeleteLaterDefault(void* ptr)
{
		static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::deleteLater();
}

void QStandardItemModel_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStandardItemModel_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QStandardItemModel_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QStandardItemModel*>(ptr)->QStandardItemModel::metaObject());
}

void* QStaticText_NewQStaticText()
{
	return new QStaticText();
}

void* QStaticText_NewQStaticText3(void* other)
{
	return new QStaticText(*static_cast<QStaticText*>(other));
}

void* QStaticText_NewQStaticText2(char* text)
{
	return new QStaticText(QString(text));
}

void QStaticText_Prepare(void* ptr, void* matrix, void* font)
{
	static_cast<QStaticText*>(ptr)->prepare(*static_cast<QTransform*>(matrix), *static_cast<QFont*>(font));
}

void QStaticText_SetPerformanceHint(void* ptr, long long performanceHint)
{
	static_cast<QStaticText*>(ptr)->setPerformanceHint(static_cast<QStaticText::PerformanceHint>(performanceHint));
}

void QStaticText_SetText(void* ptr, char* text)
{
	static_cast<QStaticText*>(ptr)->setText(QString(text));
}

void QStaticText_SetTextFormat(void* ptr, long long textFormat)
{
	static_cast<QStaticText*>(ptr)->setTextFormat(static_cast<Qt::TextFormat>(textFormat));
}

void QStaticText_SetTextOption(void* ptr, void* textOption)
{
	static_cast<QStaticText*>(ptr)->setTextOption(*static_cast<QTextOption*>(textOption));
}

void QStaticText_SetTextWidth(void* ptr, double textWidth)
{
	static_cast<QStaticText*>(ptr)->setTextWidth(textWidth);
}

void QStaticText_Swap(void* ptr, void* other)
{
	static_cast<QStaticText*>(ptr)->swap(*static_cast<QStaticText*>(other));
}

void QStaticText_DestroyQStaticText(void* ptr)
{
	static_cast<QStaticText*>(ptr)->~QStaticText();
}

long long QStaticText_PerformanceHint(void* ptr)
{
	return static_cast<QStaticText*>(ptr)->performanceHint();
}

void* QStaticText_Size(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QStaticText*>(ptr)->size(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QStaticText_Text(void* ptr)
{
	return ({ QByteArray t6fe556 = static_cast<QStaticText*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(t6fe556.prepend("WHITESPACE").constData()+10), t6fe556.size()-10 }; });
}

void* QStaticText_TextOption(void* ptr)
{
	return new QTextOption(static_cast<QStaticText*>(ptr)->textOption());
}

long long QStaticText_TextFormat(void* ptr)
{
	return static_cast<QStaticText*>(ptr)->textFormat();
}

double QStaticText_TextWidth(void* ptr)
{
	return static_cast<QStaticText*>(ptr)->textWidth();
}

class MyQStatusTipEvent: public QStatusTipEvent
{
public:
	MyQStatusTipEvent(const QString &tip) : QStatusTipEvent(tip) {};
};

void* QStatusTipEvent_NewQStatusTipEvent(char* tip)
{
	return new MyQStatusTipEvent(QString(tip));
}

struct QtGui_PackedString QStatusTipEvent_Tip(void* ptr)
{
	return ({ QByteArray t663d3b = static_cast<QStatusTipEvent*>(ptr)->tip().toUtf8(); QtGui_PackedString { const_cast<char*>(t663d3b.prepend("WHITESPACE").constData()+10), t663d3b.size()-10 }; });
}

class MyQStyleHints: public QStyleHints
{
public:
	void Signal_CursorFlashTimeChanged(int cursorFlashTime) { callbackQStyleHints_CursorFlashTimeChanged(this, cursorFlashTime); };
	void Signal_KeyboardInputIntervalChanged(int keyboardInputInterval) { callbackQStyleHints_KeyboardInputIntervalChanged(this, keyboardInputInterval); };
	void Signal_MouseDoubleClickIntervalChanged(int mouseDoubleClickInterval) { callbackQStyleHints_MouseDoubleClickIntervalChanged(this, mouseDoubleClickInterval); };
	void Signal_MousePressAndHoldIntervalChanged(int mousePressAndHoldInterval) { callbackQStyleHints_MousePressAndHoldIntervalChanged(this, mousePressAndHoldInterval); };
	void Signal_StartDragDistanceChanged(int startDragDistance) { callbackQStyleHints_StartDragDistanceChanged(this, startDragDistance); };
	void Signal_StartDragTimeChanged(int startDragTime) { callbackQStyleHints_StartDragTimeChanged(this, startDragTime); };
	void Signal_TabFocusBehaviorChanged(Qt::TabFocusBehavior tabFocusBehavior) { callbackQStyleHints_TabFocusBehaviorChanged(this, tabFocusBehavior); };
	void Signal_UseHoverEffectsChanged(bool useHoverEffects) { callbackQStyleHints_UseHoverEffectsChanged(this, useHoverEffects); };
	bool event(QEvent * e) { return callbackQStyleHints_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQStyleHints_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQStyleHints_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQStyleHints_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQStyleHints_CustomEvent(this, event); };
	void deleteLater() { callbackQStyleHints_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQStyleHints_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQStyleHints_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQStyleHints_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQStyleHints_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQStyleHints_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QStyleHints_ConnectCursorFlashTimeChanged(void* ptr)
{
	QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::cursorFlashTimeChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_CursorFlashTimeChanged));
}

void QStyleHints_DisconnectCursorFlashTimeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::cursorFlashTimeChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_CursorFlashTimeChanged));
}

void QStyleHints_CursorFlashTimeChanged(void* ptr, int cursorFlashTime)
{
	static_cast<QStyleHints*>(ptr)->cursorFlashTimeChanged(cursorFlashTime);
}

void QStyleHints_ConnectKeyboardInputIntervalChanged(void* ptr)
{
	QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::keyboardInputIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_KeyboardInputIntervalChanged));
}

void QStyleHints_DisconnectKeyboardInputIntervalChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::keyboardInputIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_KeyboardInputIntervalChanged));
}

void QStyleHints_KeyboardInputIntervalChanged(void* ptr, int keyboardInputInterval)
{
	static_cast<QStyleHints*>(ptr)->keyboardInputIntervalChanged(keyboardInputInterval);
}

void QStyleHints_ConnectMouseDoubleClickIntervalChanged(void* ptr)
{
	QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::mouseDoubleClickIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_MouseDoubleClickIntervalChanged));
}

void QStyleHints_DisconnectMouseDoubleClickIntervalChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::mouseDoubleClickIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_MouseDoubleClickIntervalChanged));
}

void QStyleHints_MouseDoubleClickIntervalChanged(void* ptr, int mouseDoubleClickInterval)
{
	static_cast<QStyleHints*>(ptr)->mouseDoubleClickIntervalChanged(mouseDoubleClickInterval);
}

void QStyleHints_ConnectMousePressAndHoldIntervalChanged(void* ptr)
{
	QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::mousePressAndHoldIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_MousePressAndHoldIntervalChanged));
}

void QStyleHints_DisconnectMousePressAndHoldIntervalChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::mousePressAndHoldIntervalChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_MousePressAndHoldIntervalChanged));
}

void QStyleHints_MousePressAndHoldIntervalChanged(void* ptr, int mousePressAndHoldInterval)
{
	static_cast<QStyleHints*>(ptr)->mousePressAndHoldIntervalChanged(mousePressAndHoldInterval);
}

void QStyleHints_SetUseHoverEffects(void* ptr, char useHoverEffects)
{
	static_cast<QStyleHints*>(ptr)->setUseHoverEffects(useHoverEffects != 0);
}

void QStyleHints_ConnectStartDragDistanceChanged(void* ptr)
{
	QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::startDragDistanceChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_StartDragDistanceChanged));
}

void QStyleHints_DisconnectStartDragDistanceChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::startDragDistanceChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_StartDragDistanceChanged));
}

void QStyleHints_StartDragDistanceChanged(void* ptr, int startDragDistance)
{
	static_cast<QStyleHints*>(ptr)->startDragDistanceChanged(startDragDistance);
}

void QStyleHints_ConnectStartDragTimeChanged(void* ptr)
{
	QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::startDragTimeChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_StartDragTimeChanged));
}

void QStyleHints_DisconnectStartDragTimeChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(int)>(&QStyleHints::startDragTimeChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(int)>(&MyQStyleHints::Signal_StartDragTimeChanged));
}

void QStyleHints_StartDragTimeChanged(void* ptr, int startDragTime)
{
	static_cast<QStyleHints*>(ptr)->startDragTimeChanged(startDragTime);
}

void QStyleHints_ConnectTabFocusBehaviorChanged(void* ptr)
{
	QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(Qt::TabFocusBehavior)>(&QStyleHints::tabFocusBehaviorChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(Qt::TabFocusBehavior)>(&MyQStyleHints::Signal_TabFocusBehaviorChanged));
}

void QStyleHints_DisconnectTabFocusBehaviorChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(Qt::TabFocusBehavior)>(&QStyleHints::tabFocusBehaviorChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(Qt::TabFocusBehavior)>(&MyQStyleHints::Signal_TabFocusBehaviorChanged));
}

void QStyleHints_TabFocusBehaviorChanged(void* ptr, long long tabFocusBehavior)
{
	static_cast<QStyleHints*>(ptr)->tabFocusBehaviorChanged(static_cast<Qt::TabFocusBehavior>(tabFocusBehavior));
}

void QStyleHints_ConnectUseHoverEffectsChanged(void* ptr)
{
	QObject::connect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(bool)>(&QStyleHints::useHoverEffectsChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(bool)>(&MyQStyleHints::Signal_UseHoverEffectsChanged));
}

void QStyleHints_DisconnectUseHoverEffectsChanged(void* ptr)
{
	QObject::disconnect(static_cast<QStyleHints*>(ptr), static_cast<void (QStyleHints::*)(bool)>(&QStyleHints::useHoverEffectsChanged), static_cast<MyQStyleHints*>(ptr), static_cast<void (MyQStyleHints::*)(bool)>(&MyQStyleHints::Signal_UseHoverEffectsChanged));
}

void QStyleHints_UseHoverEffectsChanged(void* ptr, char useHoverEffects)
{
	static_cast<QStyleHints*>(ptr)->useHoverEffectsChanged(useHoverEffects != 0);
}

void* QStyleHints_PasswordMaskCharacter(void* ptr)
{
	return new QChar(static_cast<QStyleHints*>(ptr)->passwordMaskCharacter());
}

long long QStyleHints_TabFocusBehavior(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->tabFocusBehavior();
}

char QStyleHints_SetFocusOnTouchRelease(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->setFocusOnTouchRelease();
}

char QStyleHints_ShowIsFullScreen(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->showIsFullScreen();
}

char QStyleHints_ShowIsMaximized(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->showIsMaximized();
}

char QStyleHints_SingleClickActivation(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->singleClickActivation();
}

char QStyleHints_UseHoverEffects(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->useHoverEffects();
}

char QStyleHints_UseRtlExtensions(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->useRtlExtensions();
}

int QStyleHints_CursorFlashTime(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->cursorFlashTime();
}

int QStyleHints_KeyboardAutoRepeatRate(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->keyboardAutoRepeatRate();
}

int QStyleHints_KeyboardInputInterval(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->keyboardInputInterval();
}

int QStyleHints_MouseDoubleClickInterval(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->mouseDoubleClickInterval();
}

int QStyleHints_MousePressAndHoldInterval(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->mousePressAndHoldInterval();
}

int QStyleHints_PasswordMaskDelay(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->passwordMaskDelay();
}

int QStyleHints_StartDragDistance(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->startDragDistance();
}

int QStyleHints_StartDragTime(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->startDragTime();
}

int QStyleHints_StartDragVelocity(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->startDragVelocity();
}

double QStyleHints_FontSmoothingGamma(void* ptr)
{
	return static_cast<QStyleHints*>(ptr)->fontSmoothingGamma();
}

void* QStyleHints___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QStyleHints___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QStyleHints___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QStyleHints___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QStyleHints___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QStyleHints___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QStyleHints___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QStyleHints___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QStyleHints___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QStyleHints___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QStyleHints___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QStyleHints___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QStyleHints___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QStyleHints___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QStyleHints___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QStyleHints_EventDefault(void* ptr, void* e)
{
		return static_cast<QStyleHints*>(ptr)->QStyleHints::event(static_cast<QEvent*>(e));
}

char QStyleHints_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QStyleHints*>(ptr)->QStyleHints::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QStyleHints*>(ptr)->QStyleHints::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QStyleHints*>(ptr)->QStyleHints::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QStyleHints*>(ptr)->QStyleHints::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QStyleHints*>(ptr)->QStyleHints::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QStyleHints_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QStyleHints*>(ptr)->QStyleHints::childEvent(static_cast<QChildEvent*>(event));
}

void QStyleHints_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QStyleHints*>(ptr)->QStyleHints::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStyleHints_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QStyleHints*>(ptr)->QStyleHints::customEvent(static_cast<QEvent*>(event));
}

void QStyleHints_DeleteLaterDefault(void* ptr)
{
		static_cast<QStyleHints*>(ptr)->QStyleHints::deleteLater();
}

void QStyleHints_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QStyleHints*>(ptr)->QStyleHints::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QStyleHints_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QStyleHints*>(ptr)->QStyleHints::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QStyleHints_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QStyleHints*>(ptr)->QStyleHints::metaObject());
}

class MyQSurface: public QSurface
{
public:
	 ~MyQSurface() { callbackQSurface_DestroyQSurface(this); };
	QSize size() const { return *static_cast<QSize*>(callbackQSurface_Size(const_cast<void*>(static_cast<const void*>(this)))); };
	QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQSurface_Format(const_cast<void*>(static_cast<const void*>(this)))); };
	SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQSurface_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QSurface_DestroyQSurface(void* ptr)
{
	static_cast<QSurface*>(ptr)->~QSurface();
}

void QSurface_DestroyQSurfaceDefault(void* ptr)
{

}

void* QSurface_Size(void* ptr)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QOffscreenSurface*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QSurface*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QSurface_Format(void* ptr)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
		return new QSurfaceFormat(static_cast<QOffscreenSurface*>(ptr)->format());
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QSurfaceFormat(static_cast<QPaintDeviceWindow*>(ptr)->format());
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
		return new QSurfaceFormat(static_cast<QWindow*>(ptr)->format());
	} else {
		return new QSurfaceFormat(static_cast<QSurface*>(ptr)->format());
	}
}

long long QSurface_SurfaceClass(void* ptr)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOffscreenSurface*>(ptr)->surfaceClass();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->surfaceClass();
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWindow*>(ptr)->surfaceClass();
	} else {
		return static_cast<QSurface*>(ptr)->surfaceClass();
	}
}

long long QSurface_SurfaceType(void* ptr)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOffscreenSurface*>(ptr)->surfaceType();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->surfaceType();
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWindow*>(ptr)->surfaceType();
	} else {
		return static_cast<QSurface*>(ptr)->surfaceType();
	}
}

char QSurface_SupportsOpenGL(void* ptr)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOffscreenSurface*>(ptr)->supportsOpenGL();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->supportsOpenGL();
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWindow*>(ptr)->supportsOpenGL();
	} else {
		return static_cast<QSurface*>(ptr)->supportsOpenGL();
	}
}

long long QSurface_M_type(void* ptr)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
		return static_cast<QOffscreenSurface*>(ptr)->m_type;
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->m_type;
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QWindow*>(ptr)->m_type;
	} else {
		return static_cast<QSurface*>(ptr)->m_type;
	}
}

void QSurface_SetM_type(void* ptr, long long vsu)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(ptr))) {
		static_cast<QOffscreenSurface*>(ptr)->m_type = static_cast<QSurface::SurfaceClass>(vsu);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->m_type = static_cast<QSurface::SurfaceClass>(vsu);
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QWindow*>(ptr)->m_type = static_cast<QSurface::SurfaceClass>(vsu);
	} else {
		static_cast<QSurface*>(ptr)->m_type = static_cast<QSurface::SurfaceClass>(vsu);
	}
}

void* QSurfaceFormat_QSurfaceFormat_DefaultFormat()
{
	return new QSurfaceFormat(QSurfaceFormat::defaultFormat());
}

void* QSurfaceFormat_NewQSurfaceFormat()
{
	return new QSurfaceFormat();
}

void* QSurfaceFormat_NewQSurfaceFormat2(long long options)
{
	return new QSurfaceFormat(static_cast<QSurfaceFormat::FormatOption>(options));
}

void* QSurfaceFormat_NewQSurfaceFormat3(void* other)
{
	return new QSurfaceFormat(*static_cast<QSurfaceFormat*>(other));
}

void QSurfaceFormat_SetAlphaBufferSize(void* ptr, int size)
{
	static_cast<QSurfaceFormat*>(ptr)->setAlphaBufferSize(size);
}

void QSurfaceFormat_SetBlueBufferSize(void* ptr, int size)
{
	static_cast<QSurfaceFormat*>(ptr)->setBlueBufferSize(size);
}

void QSurfaceFormat_QSurfaceFormat_SetDefaultFormat(void* format)
{
	QSurfaceFormat::setDefaultFormat(*static_cast<QSurfaceFormat*>(format));
}

void QSurfaceFormat_SetDepthBufferSize(void* ptr, int size)
{
	static_cast<QSurfaceFormat*>(ptr)->setDepthBufferSize(size);
}

void QSurfaceFormat_SetGreenBufferSize(void* ptr, int size)
{
	static_cast<QSurfaceFormat*>(ptr)->setGreenBufferSize(size);
}

void QSurfaceFormat_SetMajorVersion(void* ptr, int major)
{
	static_cast<QSurfaceFormat*>(ptr)->setMajorVersion(major);
}

void QSurfaceFormat_SetMinorVersion(void* ptr, int minor)
{
	static_cast<QSurfaceFormat*>(ptr)->setMinorVersion(minor);
}

void QSurfaceFormat_SetOption(void* ptr, long long option, char on)
{
	static_cast<QSurfaceFormat*>(ptr)->setOption(static_cast<QSurfaceFormat::FormatOption>(option), on != 0);
}

void QSurfaceFormat_SetOptions(void* ptr, long long options)
{
	static_cast<QSurfaceFormat*>(ptr)->setOptions(static_cast<QSurfaceFormat::FormatOption>(options));
}

void QSurfaceFormat_SetProfile(void* ptr, long long profile)
{
	static_cast<QSurfaceFormat*>(ptr)->setProfile(static_cast<QSurfaceFormat::OpenGLContextProfile>(profile));
}

void QSurfaceFormat_SetRedBufferSize(void* ptr, int size)
{
	static_cast<QSurfaceFormat*>(ptr)->setRedBufferSize(size);
}

void QSurfaceFormat_SetRenderableType(void* ptr, long long ty)
{
	static_cast<QSurfaceFormat*>(ptr)->setRenderableType(static_cast<QSurfaceFormat::RenderableType>(ty));
}

void QSurfaceFormat_SetSamples(void* ptr, int numSamples)
{
	static_cast<QSurfaceFormat*>(ptr)->setSamples(numSamples);
}

void QSurfaceFormat_SetStencilBufferSize(void* ptr, int size)
{
	static_cast<QSurfaceFormat*>(ptr)->setStencilBufferSize(size);
}

void QSurfaceFormat_SetStereo(void* ptr, char enable)
{
	static_cast<QSurfaceFormat*>(ptr)->setStereo(enable != 0);
}

void QSurfaceFormat_SetSwapBehavior(void* ptr, long long behavior)
{
	static_cast<QSurfaceFormat*>(ptr)->setSwapBehavior(static_cast<QSurfaceFormat::SwapBehavior>(behavior));
}

void QSurfaceFormat_SetSwapInterval(void* ptr, int interval)
{
	static_cast<QSurfaceFormat*>(ptr)->setSwapInterval(interval);
}

void QSurfaceFormat_SetVersion(void* ptr, int major, int minor)
{
	static_cast<QSurfaceFormat*>(ptr)->setVersion(major, minor);
}

void QSurfaceFormat_DestroyQSurfaceFormat(void* ptr)
{
	static_cast<QSurfaceFormat*>(ptr)->~QSurfaceFormat();
}

long long QSurfaceFormat_Profile(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->profile();
}

long long QSurfaceFormat_Options(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->options();
}

long long QSurfaceFormat_RenderableType(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->renderableType();
}

long long QSurfaceFormat_SwapBehavior(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->swapBehavior();
}

char QSurfaceFormat_HasAlpha(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->hasAlpha();
}

char QSurfaceFormat_Stereo(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->stereo();
}

char QSurfaceFormat_TestOption(void* ptr, long long option)
{
	return static_cast<QSurfaceFormat*>(ptr)->testOption(static_cast<QSurfaceFormat::FormatOption>(option));
}

int QSurfaceFormat_AlphaBufferSize(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->alphaBufferSize();
}

int QSurfaceFormat_BlueBufferSize(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->blueBufferSize();
}

int QSurfaceFormat_DepthBufferSize(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->depthBufferSize();
}

int QSurfaceFormat_GreenBufferSize(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->greenBufferSize();
}

int QSurfaceFormat_MajorVersion(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->majorVersion();
}

int QSurfaceFormat_MinorVersion(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->minorVersion();
}

int QSurfaceFormat_RedBufferSize(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->redBufferSize();
}

int QSurfaceFormat_Samples(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->samples();
}

int QSurfaceFormat_StencilBufferSize(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->stencilBufferSize();
}

int QSurfaceFormat_SwapInterval(void* ptr)
{
	return static_cast<QSurfaceFormat*>(ptr)->swapInterval();
}

class MyQSyntaxHighlighter: public QSyntaxHighlighter
{
public:
	MyQSyntaxHighlighter(QObject *parent) : QSyntaxHighlighter(parent) {};
	MyQSyntaxHighlighter(QTextDocument *parent) : QSyntaxHighlighter(parent) {};
	void highlightBlock(const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtGui_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQSyntaxHighlighter_HighlightBlock(this, textPacked); };
	void rehighlight() { callbackQSyntaxHighlighter_Rehighlight(this); };
	void rehighlightBlock(const QTextBlock & block) { callbackQSyntaxHighlighter_RehighlightBlock(this, const_cast<QTextBlock*>(&block)); };
	 ~MyQSyntaxHighlighter() { callbackQSyntaxHighlighter_DestroyQSyntaxHighlighter(this); };
	bool event(QEvent * e) { return callbackQSyntaxHighlighter_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQSyntaxHighlighter_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQSyntaxHighlighter_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQSyntaxHighlighter_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQSyntaxHighlighter_CustomEvent(this, event); };
	void deleteLater() { callbackQSyntaxHighlighter_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQSyntaxHighlighter_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQSyntaxHighlighter_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQSyntaxHighlighter_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQSyntaxHighlighter_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSyntaxHighlighter_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QSyntaxHighlighter_NewQSyntaxHighlighter(void* parent)
{
	return new MyQSyntaxHighlighter(static_cast<QObject*>(parent));
}

void* QSyntaxHighlighter_NewQSyntaxHighlighter2(void* parent)
{
	return new MyQSyntaxHighlighter(static_cast<QTextDocument*>(parent));
}

void QSyntaxHighlighter_HighlightBlock(void* ptr, char* text)
{
	static_cast<QSyntaxHighlighter*>(ptr)->highlightBlock(QString(text));
}

void QSyntaxHighlighter_Rehighlight(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QSyntaxHighlighter*>(ptr), "rehighlight");
}

void QSyntaxHighlighter_RehighlightDefault(void* ptr)
{
		static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::rehighlight();
}

void QSyntaxHighlighter_RehighlightBlock(void* ptr, void* block)
{
	QMetaObject::invokeMethod(static_cast<QSyntaxHighlighter*>(ptr), "rehighlightBlock", Q_ARG(QTextBlock, *static_cast<QTextBlock*>(block)));
}

void QSyntaxHighlighter_RehighlightBlockDefault(void* ptr, void* block)
{
		static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::rehighlightBlock(*static_cast<QTextBlock*>(block));
}

void QSyntaxHighlighter_SetCurrentBlockState(void* ptr, int newState)
{
	static_cast<QSyntaxHighlighter*>(ptr)->setCurrentBlockState(newState);
}

void QSyntaxHighlighter_SetCurrentBlockUserData(void* ptr, void* data)
{
	static_cast<QSyntaxHighlighter*>(ptr)->setCurrentBlockUserData(static_cast<QTextBlockUserData*>(data));
}

void QSyntaxHighlighter_SetDocument(void* ptr, void* doc)
{
	static_cast<QSyntaxHighlighter*>(ptr)->setDocument(static_cast<QTextDocument*>(doc));
}

void QSyntaxHighlighter_SetFormat2(void* ptr, int start, int count, void* color)
{
	static_cast<QSyntaxHighlighter*>(ptr)->setFormat(start, count, *static_cast<QColor*>(color));
}

void QSyntaxHighlighter_SetFormat3(void* ptr, int start, int count, void* font)
{
	static_cast<QSyntaxHighlighter*>(ptr)->setFormat(start, count, *static_cast<QFont*>(font));
}

void QSyntaxHighlighter_SetFormat(void* ptr, int start, int count, void* format)
{
	static_cast<QSyntaxHighlighter*>(ptr)->setFormat(start, count, *static_cast<QTextCharFormat*>(format));
}

void QSyntaxHighlighter_DestroyQSyntaxHighlighter(void* ptr)
{
	static_cast<QSyntaxHighlighter*>(ptr)->~QSyntaxHighlighter();
}

void QSyntaxHighlighter_DestroyQSyntaxHighlighterDefault(void* ptr)
{

}

void* QSyntaxHighlighter_CurrentBlock(void* ptr)
{
	return new QTextBlock(static_cast<QSyntaxHighlighter*>(ptr)->currentBlock());
}

void* QSyntaxHighlighter_CurrentBlockUserData(void* ptr)
{
	return static_cast<QSyntaxHighlighter*>(ptr)->currentBlockUserData();
}

void* QSyntaxHighlighter_Format(void* ptr, int position)
{
	return new QTextCharFormat(static_cast<QSyntaxHighlighter*>(ptr)->format(position));
}

void* QSyntaxHighlighter_Document(void* ptr)
{
	return static_cast<QSyntaxHighlighter*>(ptr)->document();
}

int QSyntaxHighlighter_CurrentBlockState(void* ptr)
{
	return static_cast<QSyntaxHighlighter*>(ptr)->currentBlockState();
}

int QSyntaxHighlighter_PreviousBlockState(void* ptr)
{
	return static_cast<QSyntaxHighlighter*>(ptr)->previousBlockState();
}

void* QSyntaxHighlighter___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QSyntaxHighlighter___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QSyntaxHighlighter___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QSyntaxHighlighter___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSyntaxHighlighter___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSyntaxHighlighter___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QSyntaxHighlighter___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSyntaxHighlighter___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSyntaxHighlighter___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QSyntaxHighlighter___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QSyntaxHighlighter___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSyntaxHighlighter___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QSyntaxHighlighter___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QSyntaxHighlighter___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QSyntaxHighlighter___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QSyntaxHighlighter_EventDefault(void* ptr, void* e)
{
		return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::event(static_cast<QEvent*>(e));
}

char QSyntaxHighlighter_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QSyntaxHighlighter_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::childEvent(static_cast<QChildEvent*>(event));
}

void QSyntaxHighlighter_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSyntaxHighlighter_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::customEvent(static_cast<QEvent*>(event));
}

void QSyntaxHighlighter_DeleteLaterDefault(void* ptr)
{
		static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::deleteLater();
}

void QSyntaxHighlighter_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QSyntaxHighlighter_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QSyntaxHighlighter_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QSyntaxHighlighter*>(ptr)->QSyntaxHighlighter::metaObject());
}

class MyQTabletEvent: public QTabletEvent
{
public:
	MyQTabletEvent(Type type, const QPointF &pos, const QPointF &globalPos, int device, int pointerType, qreal pressure, int xTilt, int yTilt, qreal tangentialPressure, qreal rotation, int z, Qt::KeyboardModifiers keyState, qint64 uniqueID, Qt::MouseButton button, Qt::MouseButtons buttons) : QTabletEvent(type, pos, globalPos, device, pointerType, pressure, xTilt, yTilt, tangentialPressure, rotation, z, keyState, uniqueID, button, buttons) {};
};

void* QTabletEvent_NewQTabletEvent(long long ty, void* pos, void* globalPos, int device, int pointerType, double pressure, int xTilt, int yTilt, double tangentialPressure, double rotation, int z, long long keyState, long long uniqueID, long long button, long long buttons)
{
	return new MyQTabletEvent(static_cast<QEvent::Type>(ty), *static_cast<QPointF*>(pos), *static_cast<QPointF*>(globalPos), device, pointerType, pressure, xTilt, yTilt, tangentialPressure, rotation, z, static_cast<Qt::KeyboardModifier>(keyState), uniqueID, static_cast<Qt::MouseButton>(button), static_cast<Qt::MouseButton>(buttons));
}

long long QTabletEvent_PointerType(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->pointerType();
}

void* QTabletEvent_GlobalPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QTabletEvent*>(ptr)->globalPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QTabletEvent_Pos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QTabletEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

long long QTabletEvent_Button(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->button();
}

long long QTabletEvent_Buttons(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->buttons();
}

long long QTabletEvent_Device(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->device();
}

void* QTabletEvent_GlobalPosF(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QTabletEvent*>(ptr)->globalPosF());
}

void* QTabletEvent_PosF(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QTabletEvent*>(ptr)->posF());
}

int QTabletEvent_GlobalX(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->globalX();
}

int QTabletEvent_GlobalY(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->globalY();
}

int QTabletEvent_X(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->x();
}

int QTabletEvent_XTilt(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->xTilt();
}

int QTabletEvent_Y(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->y();
}

int QTabletEvent_YTilt(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->yTilt();
}

int QTabletEvent_Z(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->z();
}

long long QTabletEvent_UniqueId(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->uniqueId();
}

double QTabletEvent_HiResGlobalX(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->hiResGlobalX();
}

double QTabletEvent_HiResGlobalY(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->hiResGlobalY();
}

double QTabletEvent_Pressure(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->pressure();
}

double QTabletEvent_Rotation(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->rotation();
}

double QTabletEvent_TangentialPressure(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->tangentialPressure();
}

void* QTabletEvent_MExtra(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->mExtra;
}

void QTabletEvent_SetMExtra(void* ptr, void* vvo)
{
	static_cast<QTabletEvent*>(ptr)->mExtra = vvo;
}

long long QTabletEvent_MUnique(void* ptr)
{
	return static_cast<QTabletEvent*>(ptr)->mUnique;
}

void QTabletEvent_SetMUnique(void* ptr, long long vqi)
{
	static_cast<QTabletEvent*>(ptr)->mUnique = vqi;
}

void* QTextBlock_NewQTextBlock(void* other)
{
	return new QTextBlock(*static_cast<QTextBlock*>(other));
}

void QTextBlock_ClearLayout(void* ptr)
{
	static_cast<QTextBlock*>(ptr)->clearLayout();
}

void QTextBlock_SetLineCount(void* ptr, int count)
{
	static_cast<QTextBlock*>(ptr)->setLineCount(count);
}

void QTextBlock_SetRevision(void* ptr, int rev)
{
	static_cast<QTextBlock*>(ptr)->setRevision(rev);
}

void QTextBlock_SetUserData(void* ptr, void* data)
{
	static_cast<QTextBlock*>(ptr)->setUserData(static_cast<QTextBlockUserData*>(data));
}

void QTextBlock_SetUserState(void* ptr, int state)
{
	static_cast<QTextBlock*>(ptr)->setUserState(state);
}

void QTextBlock_SetVisible(void* ptr, char visible)
{
	static_cast<QTextBlock*>(ptr)->setVisible(visible != 0);
}

struct QtGui_PackedString QTextBlock_Text(void* ptr)
{
	return ({ QByteArray t4bcf6c = static_cast<QTextBlock*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(t4bcf6c.prepend("WHITESPACE").constData()+10), t4bcf6c.size()-10 }; });
}

void* QTextBlock_Next(void* ptr)
{
	return new QTextBlock(static_cast<QTextBlock*>(ptr)->next());
}

void* QTextBlock_Previous(void* ptr)
{
	return new QTextBlock(static_cast<QTextBlock*>(ptr)->previous());
}

void* QTextBlock_BlockFormat(void* ptr)
{
	return new QTextBlockFormat(static_cast<QTextBlock*>(ptr)->blockFormat());
}

void* QTextBlock_UserData(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->userData();
}

void* QTextBlock_CharFormat(void* ptr)
{
	return new QTextCharFormat(static_cast<QTextBlock*>(ptr)->charFormat());
}

void* QTextBlock_Layout(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->layout();
}

long long QTextBlock_TextDirection(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->textDirection();
}

char QTextBlock_Contains(void* ptr, int position)
{
	return static_cast<QTextBlock*>(ptr)->contains(position);
}

char QTextBlock_IsValid(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->isValid();
}

char QTextBlock_IsVisible(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->isVisible();
}

void* QTextBlock_Document(void* ptr)
{
	return const_cast<QTextDocument*>(static_cast<QTextBlock*>(ptr)->document());
}

int QTextBlock_BlockFormatIndex(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->blockFormatIndex();
}

int QTextBlock_BlockNumber(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->blockNumber();
}

int QTextBlock_CharFormatIndex(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->charFormatIndex();
}

int QTextBlock_FirstLineNumber(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->firstLineNumber();
}

int QTextBlock_Length(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->length();
}

int QTextBlock_LineCount(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->lineCount();
}

int QTextBlock_Position(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->position();
}

int QTextBlock_Revision(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->revision();
}

int QTextBlock_UserState(void* ptr)
{
	return static_cast<QTextBlock*>(ptr)->userState();
}

void* QTextBlock___textFormats_newList(void* ptr)
{
	return new QVector<QTextLayout::FormatRange>;
}

void* QTextBlockFormat_NewQTextBlockFormat()
{
	return new QTextBlockFormat();
}

void QTextBlockFormat_SetAlignment(void* ptr, long long alignment)
{
	static_cast<QTextBlockFormat*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QTextBlockFormat_SetBottomMargin(void* ptr, double margin)
{
	static_cast<QTextBlockFormat*>(ptr)->setBottomMargin(margin);
}

void QTextBlockFormat_SetIndent(void* ptr, int indentation)
{
	static_cast<QTextBlockFormat*>(ptr)->setIndent(indentation);
}

void QTextBlockFormat_SetLeftMargin(void* ptr, double margin)
{
	static_cast<QTextBlockFormat*>(ptr)->setLeftMargin(margin);
}

void QTextBlockFormat_SetLineHeight(void* ptr, double height, int heightType)
{
	static_cast<QTextBlockFormat*>(ptr)->setLineHeight(height, heightType);
}

void QTextBlockFormat_SetNonBreakableLines(void* ptr, char b)
{
	static_cast<QTextBlockFormat*>(ptr)->setNonBreakableLines(b != 0);
}

void QTextBlockFormat_SetPageBreakPolicy(void* ptr, long long policy)
{
	static_cast<QTextBlockFormat*>(ptr)->setPageBreakPolicy(static_cast<QTextFormat::PageBreakFlag>(policy));
}

void QTextBlockFormat_SetRightMargin(void* ptr, double margin)
{
	static_cast<QTextBlockFormat*>(ptr)->setRightMargin(margin);
}

void QTextBlockFormat_SetTextIndent(void* ptr, double indent)
{
	static_cast<QTextBlockFormat*>(ptr)->setTextIndent(indent);
}

void QTextBlockFormat_SetTopMargin(void* ptr, double margin)
{
	static_cast<QTextBlockFormat*>(ptr)->setTopMargin(margin);
}

long long QTextBlockFormat_PageBreakPolicy(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->pageBreakPolicy();
}

long long QTextBlockFormat_Alignment(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->alignment();
}

char QTextBlockFormat_NonBreakableLines(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->nonBreakableLines();
}

int QTextBlockFormat_Indent(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->indent();
}

int QTextBlockFormat_LineHeightType(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->lineHeightType();
}

double QTextBlockFormat_BottomMargin(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->bottomMargin();
}

double QTextBlockFormat_LeftMargin(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->leftMargin();
}

double QTextBlockFormat_LineHeight2(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->lineHeight();
}

double QTextBlockFormat_LineHeight(void* ptr, double scriptLineHeight, double scaling)
{
	return static_cast<QTextBlockFormat*>(ptr)->lineHeight(scriptLineHeight, scaling);
}

double QTextBlockFormat_RightMargin(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->rightMargin();
}

double QTextBlockFormat_TextIndent(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->textIndent();
}

double QTextBlockFormat_TopMargin(void* ptr)
{
	return static_cast<QTextBlockFormat*>(ptr)->topMargin();
}

void* QTextBlockFormat___setTabPositions_tabs_newList(void* ptr)
{
	return new QList<QTextOption::Tab>;
}

void* QTextBlockFormat___tabPositions_newList(void* ptr)
{
	return new QList<QTextOption::Tab>;
}

class MyQTextBlockGroup: public QTextBlockGroup
{
public:
	MyQTextBlockGroup(QTextDocument *document) : QTextBlockGroup(document) {};
	void blockFormatChanged(const QTextBlock & block) { callbackQTextBlockGroup_BlockFormatChanged(this, const_cast<QTextBlock*>(&block)); };
	void blockInserted(const QTextBlock & block) { callbackQTextBlockGroup_BlockInserted(this, const_cast<QTextBlock*>(&block)); };
	void blockRemoved(const QTextBlock & block) { callbackQTextBlockGroup_BlockRemoved(this, const_cast<QTextBlock*>(&block)); };
	bool event(QEvent * e) { return callbackQTextObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextObject_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQTextObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTextObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTextObject_CustomEvent(this, event); };
	void deleteLater() { callbackQTextObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQTextObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTextObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQTextObject_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QTextBlockGroup_NewQTextBlockGroup(void* document)
{
	return new MyQTextBlockGroup(static_cast<QTextDocument*>(document));
}

void QTextBlockGroup_BlockFormatChanged(void* ptr, void* block)
{
	static_cast<QTextBlockGroup*>(ptr)->blockFormatChanged(*static_cast<QTextBlock*>(block));
}

void QTextBlockGroup_BlockFormatChangedDefault(void* ptr, void* block)
{
	if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextList*>(ptr)->QTextList::blockFormatChanged(*static_cast<QTextBlock*>(block));
	} else {
		static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::blockFormatChanged(*static_cast<QTextBlock*>(block));
	}
}

void QTextBlockGroup_BlockInserted(void* ptr, void* block)
{
	static_cast<QTextBlockGroup*>(ptr)->blockInserted(*static_cast<QTextBlock*>(block));
}

void QTextBlockGroup_BlockInsertedDefault(void* ptr, void* block)
{
	if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextList*>(ptr)->QTextList::blockInserted(*static_cast<QTextBlock*>(block));
	} else {
		static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::blockInserted(*static_cast<QTextBlock*>(block));
	}
}

void QTextBlockGroup_BlockRemoved(void* ptr, void* block)
{
	static_cast<QTextBlockGroup*>(ptr)->blockRemoved(*static_cast<QTextBlock*>(block));
}

void QTextBlockGroup_BlockRemovedDefault(void* ptr, void* block)
{
	if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextList*>(ptr)->QTextList::blockRemoved(*static_cast<QTextBlock*>(block));
	} else {
		static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::blockRemoved(*static_cast<QTextBlock*>(block));
	}
}

void QTextBlockGroup_DestroyQTextBlockGroup(void* ptr)
{
	static_cast<QTextBlockGroup*>(ptr)->~QTextBlockGroup();
}

struct QtGui_PackedList QTextBlockGroup_BlockList(void* ptr)
{
	return ({ QList<QTextBlock>* tmpValue = new QList<QTextBlock>(static_cast<QTextBlockGroup*>(ptr)->blockList()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QTextBlockGroup___blockList_atList(void* ptr, int i)
{
	return new QTextBlock(static_cast<QList<QTextBlock>*>(ptr)->at(i));
}

void QTextBlockGroup___blockList_setList(void* ptr, void* i)
{
	static_cast<QList<QTextBlock>*>(ptr)->append(*static_cast<QTextBlock*>(i));
}

void* QTextBlockGroup___blockList_newList(void* ptr)
{
	return new QList<QTextBlock>;
}

class MyQTextBlockUserData: public QTextBlockUserData
{
public:
	 ~MyQTextBlockUserData() { callbackQTextBlockUserData_DestroyQTextBlockUserData(this); };
};

void QTextBlockUserData_DestroyQTextBlockUserData(void* ptr)
{
	static_cast<QTextBlockUserData*>(ptr)->~QTextBlockUserData();
}

void QTextBlockUserData_DestroyQTextBlockUserDataDefault(void* ptr)
{

}

void* QTextCharFormat_NewQTextCharFormat()
{
	return new QTextCharFormat();
}

void QTextCharFormat_SetUnderlineStyle(void* ptr, long long style)
{
	static_cast<QTextCharFormat*>(ptr)->setUnderlineStyle(static_cast<QTextCharFormat::UnderlineStyle>(style));
}

struct QtGui_PackedString QTextCharFormat_AnchorNames(void* ptr)
{
	return ({ QByteArray t55bd77 = static_cast<QTextCharFormat*>(ptr)->anchorNames().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t55bd77.prepend("WHITESPACE").constData()+10), t55bd77.size()-10 }; });
}

char QTextCharFormat_FontUnderline(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontUnderline();
}

void QTextCharFormat_SetAnchor(void* ptr, char anchor)
{
	static_cast<QTextCharFormat*>(ptr)->setAnchor(anchor != 0);
}

void QTextCharFormat_SetAnchorHref(void* ptr, char* value)
{
	static_cast<QTextCharFormat*>(ptr)->setAnchorHref(QString(value));
}

void QTextCharFormat_SetAnchorNames(void* ptr, char* names)
{
	static_cast<QTextCharFormat*>(ptr)->setAnchorNames(QString(names).split("|", QString::SkipEmptyParts));
}

void QTextCharFormat_SetFont2(void* ptr, void* font)
{
	static_cast<QTextCharFormat*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QTextCharFormat_SetFont(void* ptr, void* font, long long behavior)
{
	static_cast<QTextCharFormat*>(ptr)->setFont(*static_cast<QFont*>(font), static_cast<QTextCharFormat::FontPropertiesInheritanceBehavior>(behavior));
}

void QTextCharFormat_SetFontCapitalization(void* ptr, long long capitalization)
{
	static_cast<QTextCharFormat*>(ptr)->setFontCapitalization(static_cast<QFont::Capitalization>(capitalization));
}

void QTextCharFormat_SetFontFamily(void* ptr, char* family)
{
	static_cast<QTextCharFormat*>(ptr)->setFontFamily(QString(family));
}

void QTextCharFormat_SetFontFixedPitch(void* ptr, char fixedPitch)
{
	static_cast<QTextCharFormat*>(ptr)->setFontFixedPitch(fixedPitch != 0);
}

void QTextCharFormat_SetFontHintingPreference(void* ptr, long long hintingPreference)
{
	static_cast<QTextCharFormat*>(ptr)->setFontHintingPreference(static_cast<QFont::HintingPreference>(hintingPreference));
}

void QTextCharFormat_SetFontItalic(void* ptr, char italic)
{
	static_cast<QTextCharFormat*>(ptr)->setFontItalic(italic != 0);
}

void QTextCharFormat_SetFontKerning(void* ptr, char enable)
{
	static_cast<QTextCharFormat*>(ptr)->setFontKerning(enable != 0);
}

void QTextCharFormat_SetFontLetterSpacing(void* ptr, double spacing)
{
	static_cast<QTextCharFormat*>(ptr)->setFontLetterSpacing(spacing);
}

void QTextCharFormat_SetFontLetterSpacingType(void* ptr, long long letterSpacingType)
{
	static_cast<QTextCharFormat*>(ptr)->setFontLetterSpacingType(static_cast<QFont::SpacingType>(letterSpacingType));
}

void QTextCharFormat_SetFontOverline(void* ptr, char overline)
{
	static_cast<QTextCharFormat*>(ptr)->setFontOverline(overline != 0);
}

void QTextCharFormat_SetFontPointSize(void* ptr, double size)
{
	static_cast<QTextCharFormat*>(ptr)->setFontPointSize(size);
}

void QTextCharFormat_SetFontStretch(void* ptr, int factor)
{
	static_cast<QTextCharFormat*>(ptr)->setFontStretch(factor);
}

void QTextCharFormat_SetFontStrikeOut(void* ptr, char strikeOut)
{
	static_cast<QTextCharFormat*>(ptr)->setFontStrikeOut(strikeOut != 0);
}

void QTextCharFormat_SetFontStyleHint(void* ptr, long long hint, long long strategy)
{
	static_cast<QTextCharFormat*>(ptr)->setFontStyleHint(static_cast<QFont::StyleHint>(hint), static_cast<QFont::StyleStrategy>(strategy));
}

void QTextCharFormat_SetFontStyleStrategy(void* ptr, long long strategy)
{
	static_cast<QTextCharFormat*>(ptr)->setFontStyleStrategy(static_cast<QFont::StyleStrategy>(strategy));
}

void QTextCharFormat_SetFontUnderline(void* ptr, char underline)
{
	static_cast<QTextCharFormat*>(ptr)->setFontUnderline(underline != 0);
}

void QTextCharFormat_SetFontWeight(void* ptr, int weight)
{
	static_cast<QTextCharFormat*>(ptr)->setFontWeight(weight);
}

void QTextCharFormat_SetFontWordSpacing(void* ptr, double spacing)
{
	static_cast<QTextCharFormat*>(ptr)->setFontWordSpacing(spacing);
}

void QTextCharFormat_SetTextOutline(void* ptr, void* pen)
{
	static_cast<QTextCharFormat*>(ptr)->setTextOutline(*static_cast<QPen*>(pen));
}

void QTextCharFormat_SetToolTip(void* ptr, char* text)
{
	static_cast<QTextCharFormat*>(ptr)->setToolTip(QString(text));
}

void QTextCharFormat_SetUnderlineColor(void* ptr, void* color)
{
	static_cast<QTextCharFormat*>(ptr)->setUnderlineColor(*static_cast<QColor*>(color));
}

void QTextCharFormat_SetVerticalAlignment(void* ptr, long long alignment)
{
	static_cast<QTextCharFormat*>(ptr)->setVerticalAlignment(static_cast<QTextCharFormat::VerticalAlignment>(alignment));
}

void* QTextCharFormat_UnderlineColor(void* ptr)
{
	return new QColor(static_cast<QTextCharFormat*>(ptr)->underlineColor());
}

void* QTextCharFormat_Font(void* ptr)
{
	return new QFont(static_cast<QTextCharFormat*>(ptr)->font());
}

long long QTextCharFormat_FontCapitalization(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontCapitalization();
}

long long QTextCharFormat_FontHintingPreference(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontHintingPreference();
}

long long QTextCharFormat_FontLetterSpacingType(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontLetterSpacingType();
}

long long QTextCharFormat_FontStyleHint(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontStyleHint();
}

long long QTextCharFormat_FontStyleStrategy(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontStyleStrategy();
}

void* QTextCharFormat_TextOutline(void* ptr)
{
	return new QPen(static_cast<QTextCharFormat*>(ptr)->textOutline());
}

struct QtGui_PackedString QTextCharFormat_AnchorHref(void* ptr)
{
	return ({ QByteArray t7b8d88 = static_cast<QTextCharFormat*>(ptr)->anchorHref().toUtf8(); QtGui_PackedString { const_cast<char*>(t7b8d88.prepend("WHITESPACE").constData()+10), t7b8d88.size()-10 }; });
}

struct QtGui_PackedString QTextCharFormat_FontFamily(void* ptr)
{
	return ({ QByteArray t087f3f = static_cast<QTextCharFormat*>(ptr)->fontFamily().toUtf8(); QtGui_PackedString { const_cast<char*>(t087f3f.prepend("WHITESPACE").constData()+10), t087f3f.size()-10 }; });
}

struct QtGui_PackedString QTextCharFormat_ToolTip(void* ptr)
{
	return ({ QByteArray t7e7f7f = static_cast<QTextCharFormat*>(ptr)->toolTip().toUtf8(); QtGui_PackedString { const_cast<char*>(t7e7f7f.prepend("WHITESPACE").constData()+10), t7e7f7f.size()-10 }; });
}

long long QTextCharFormat_UnderlineStyle(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->underlineStyle();
}

long long QTextCharFormat_VerticalAlignment(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->verticalAlignment();
}

char QTextCharFormat_FontFixedPitch(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontFixedPitch();
}

char QTextCharFormat_FontItalic(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontItalic();
}

char QTextCharFormat_FontKerning(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontKerning();
}

char QTextCharFormat_FontOverline(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontOverline();
}

char QTextCharFormat_FontStrikeOut(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontStrikeOut();
}

char QTextCharFormat_IsAnchor(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->isAnchor();
}

int QTextCharFormat_FontStretch(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontStretch();
}

int QTextCharFormat_FontWeight(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontWeight();
}

double QTextCharFormat_FontLetterSpacing(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontLetterSpacing();
}

double QTextCharFormat_FontPointSize(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontPointSize();
}

double QTextCharFormat_FontWordSpacing(void* ptr)
{
	return static_cast<QTextCharFormat*>(ptr)->fontWordSpacing();
}

void* QTextCursor_NewQTextCursor()
{
	return new QTextCursor();
}

void* QTextCursor_NewQTextCursor2(void* document)
{
	return new QTextCursor(static_cast<QTextDocument*>(document));
}

void* QTextCursor_NewQTextCursor5(void* frame)
{
	return new QTextCursor(static_cast<QTextFrame*>(frame));
}

void* QTextCursor_NewQTextCursor6(void* block)
{
	return new QTextCursor(*static_cast<QTextBlock*>(block));
}

void* QTextCursor_NewQTextCursor7(void* cursor)
{
	return new QTextCursor(*static_cast<QTextCursor*>(cursor));
}

void* QTextCursor_InsertFrame(void* ptr, void* format)
{
	return static_cast<QTextCursor*>(ptr)->insertFrame(*static_cast<QTextFrameFormat*>(format));
}

void* QTextCursor_CreateList2(void* ptr, long long style)
{
	return static_cast<QTextCursor*>(ptr)->createList(static_cast<QTextListFormat::Style>(style));
}

void* QTextCursor_CreateList(void* ptr, void* format)
{
	return static_cast<QTextCursor*>(ptr)->createList(*static_cast<QTextListFormat*>(format));
}

void* QTextCursor_InsertList2(void* ptr, long long style)
{
	return static_cast<QTextCursor*>(ptr)->insertList(static_cast<QTextListFormat::Style>(style));
}

void* QTextCursor_InsertList(void* ptr, void* format)
{
	return static_cast<QTextCursor*>(ptr)->insertList(*static_cast<QTextListFormat*>(format));
}

void* QTextCursor_InsertTable2(void* ptr, int rows, int columns)
{
	return static_cast<QTextCursor*>(ptr)->insertTable(rows, columns);
}

void* QTextCursor_InsertTable(void* ptr, int rows, int columns, void* format)
{
	return static_cast<QTextCursor*>(ptr)->insertTable(rows, columns, *static_cast<QTextTableFormat*>(format));
}

char QTextCursor_MovePosition(void* ptr, long long operation, long long mode, int n)
{
	return static_cast<QTextCursor*>(ptr)->movePosition(static_cast<QTextCursor::MoveOperation>(operation), static_cast<QTextCursor::MoveMode>(mode), n);
}

void QTextCursor_BeginEditBlock(void* ptr)
{
	static_cast<QTextCursor*>(ptr)->beginEditBlock();
}

void QTextCursor_ClearSelection(void* ptr)
{
	static_cast<QTextCursor*>(ptr)->clearSelection();
}

void QTextCursor_DeleteChar(void* ptr)
{
	static_cast<QTextCursor*>(ptr)->deleteChar();
}

void QTextCursor_DeletePreviousChar(void* ptr)
{
	static_cast<QTextCursor*>(ptr)->deletePreviousChar();
}

void QTextCursor_EndEditBlock(void* ptr)
{
	static_cast<QTextCursor*>(ptr)->endEditBlock();
}

void QTextCursor_InsertBlock(void* ptr)
{
	static_cast<QTextCursor*>(ptr)->insertBlock();
}

void QTextCursor_InsertBlock2(void* ptr, void* format)
{
	static_cast<QTextCursor*>(ptr)->insertBlock(*static_cast<QTextBlockFormat*>(format));
}

void QTextCursor_InsertBlock3(void* ptr, void* format, void* charFormat)
{
	static_cast<QTextCursor*>(ptr)->insertBlock(*static_cast<QTextBlockFormat*>(format), *static_cast<QTextCharFormat*>(charFormat));
}

void QTextCursor_InsertFragment(void* ptr, void* fragment)
{
	static_cast<QTextCursor*>(ptr)->insertFragment(*static_cast<QTextDocumentFragment*>(fragment));
}

void QTextCursor_InsertHtml(void* ptr, char* html)
{
	static_cast<QTextCursor*>(ptr)->insertHtml(QString(html));
}

void QTextCursor_InsertImage4(void* ptr, void* image, char* name)
{
	static_cast<QTextCursor*>(ptr)->insertImage(*static_cast<QImage*>(image), QString(name));
}

void QTextCursor_InsertImage3(void* ptr, char* name)
{
	static_cast<QTextCursor*>(ptr)->insertImage(QString(name));
}

void QTextCursor_InsertImage(void* ptr, void* format)
{
	static_cast<QTextCursor*>(ptr)->insertImage(*static_cast<QTextImageFormat*>(format));
}

void QTextCursor_InsertImage2(void* ptr, void* format, long long alignment)
{
	static_cast<QTextCursor*>(ptr)->insertImage(*static_cast<QTextImageFormat*>(format), static_cast<QTextFrameFormat::Position>(alignment));
}

void QTextCursor_InsertText(void* ptr, char* text)
{
	static_cast<QTextCursor*>(ptr)->insertText(QString(text));
}

void QTextCursor_InsertText2(void* ptr, char* text, void* format)
{
	static_cast<QTextCursor*>(ptr)->insertText(QString(text), *static_cast<QTextCharFormat*>(format));
}

void QTextCursor_JoinPreviousEditBlock(void* ptr)
{
	static_cast<QTextCursor*>(ptr)->joinPreviousEditBlock();
}

void QTextCursor_MergeBlockCharFormat(void* ptr, void* modifier)
{
	static_cast<QTextCursor*>(ptr)->mergeBlockCharFormat(*static_cast<QTextCharFormat*>(modifier));
}

void QTextCursor_MergeBlockFormat(void* ptr, void* modifier)
{
	static_cast<QTextCursor*>(ptr)->mergeBlockFormat(*static_cast<QTextBlockFormat*>(modifier));
}

void QTextCursor_MergeCharFormat(void* ptr, void* modifier)
{
	static_cast<QTextCursor*>(ptr)->mergeCharFormat(*static_cast<QTextCharFormat*>(modifier));
}

void QTextCursor_RemoveSelectedText(void* ptr)
{
	static_cast<QTextCursor*>(ptr)->removeSelectedText();
}

void QTextCursor_Select(void* ptr, long long selection)
{
	static_cast<QTextCursor*>(ptr)->select(static_cast<QTextCursor::SelectionType>(selection));
}

void QTextCursor_SetBlockCharFormat(void* ptr, void* format)
{
	static_cast<QTextCursor*>(ptr)->setBlockCharFormat(*static_cast<QTextCharFormat*>(format));
}

void QTextCursor_SetBlockFormat(void* ptr, void* format)
{
	static_cast<QTextCursor*>(ptr)->setBlockFormat(*static_cast<QTextBlockFormat*>(format));
}

void QTextCursor_SetCharFormat(void* ptr, void* format)
{
	static_cast<QTextCursor*>(ptr)->setCharFormat(*static_cast<QTextCharFormat*>(format));
}

void QTextCursor_SetKeepPositionOnInsert(void* ptr, char b)
{
	static_cast<QTextCursor*>(ptr)->setKeepPositionOnInsert(b != 0);
}

void QTextCursor_SetPosition(void* ptr, int pos, long long m)
{
	static_cast<QTextCursor*>(ptr)->setPosition(pos, static_cast<QTextCursor::MoveMode>(m));
}

void QTextCursor_SetVerticalMovementX(void* ptr, int x)
{
	static_cast<QTextCursor*>(ptr)->setVerticalMovementX(x);
}

void QTextCursor_SetVisualNavigation(void* ptr, char b)
{
	static_cast<QTextCursor*>(ptr)->setVisualNavigation(b != 0);
}

void QTextCursor_Swap(void* ptr, void* other)
{
	static_cast<QTextCursor*>(ptr)->swap(*static_cast<QTextCursor*>(other));
}

void QTextCursor_DestroyQTextCursor(void* ptr)
{
	static_cast<QTextCursor*>(ptr)->~QTextCursor();
}

struct QtGui_PackedString QTextCursor_SelectedText(void* ptr)
{
	return ({ QByteArray t495ef8 = static_cast<QTextCursor*>(ptr)->selectedText().toUtf8(); QtGui_PackedString { const_cast<char*>(t495ef8.prepend("WHITESPACE").constData()+10), t495ef8.size()-10 }; });
}

void* QTextCursor_Block(void* ptr)
{
	return new QTextBlock(static_cast<QTextCursor*>(ptr)->block());
}

void* QTextCursor_BlockFormat(void* ptr)
{
	return new QTextBlockFormat(static_cast<QTextCursor*>(ptr)->blockFormat());
}

void* QTextCursor_BlockCharFormat(void* ptr)
{
	return new QTextCharFormat(static_cast<QTextCursor*>(ptr)->blockCharFormat());
}

void* QTextCursor_CharFormat(void* ptr)
{
	return new QTextCharFormat(static_cast<QTextCursor*>(ptr)->charFormat());
}

void* QTextCursor_Document(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->document();
}

void* QTextCursor_Selection(void* ptr)
{
	return new QTextDocumentFragment(static_cast<QTextCursor*>(ptr)->selection());
}

void* QTextCursor_CurrentFrame(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->currentFrame();
}

void* QTextCursor_CurrentList(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->currentList();
}

void* QTextCursor_CurrentTable(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->currentTable();
}

char QTextCursor_AtBlockEnd(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->atBlockEnd();
}

char QTextCursor_AtBlockStart(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->atBlockStart();
}

char QTextCursor_AtEnd(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->atEnd();
}

char QTextCursor_AtStart(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->atStart();
}

char QTextCursor_HasComplexSelection(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->hasComplexSelection();
}

char QTextCursor_HasSelection(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->hasSelection();
}

char QTextCursor_IsCopyOf(void* ptr, void* other)
{
	return static_cast<QTextCursor*>(ptr)->isCopyOf(*static_cast<QTextCursor*>(other));
}

char QTextCursor_IsNull(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->isNull();
}

char QTextCursor_KeepPositionOnInsert(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->keepPositionOnInsert();
}

char QTextCursor_VisualNavigation(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->visualNavigation();
}

int QTextCursor_Anchor(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->anchor();
}

int QTextCursor_BlockNumber(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->blockNumber();
}

int QTextCursor_ColumnNumber(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->columnNumber();
}

int QTextCursor_Position(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->position();
}

int QTextCursor_PositionInBlock(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->positionInBlock();
}

int QTextCursor_SelectionEnd(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->selectionEnd();
}

int QTextCursor_SelectionStart(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->selectionStart();
}

int QTextCursor_VerticalMovementX(void* ptr)
{
	return static_cast<QTextCursor*>(ptr)->verticalMovementX();
}

void QTextCursor_SelectedTableCells(void* ptr, int firstRow, int numRows, int firstColumn, int numColumns)
{
	static_cast<QTextCursor*>(ptr)->selectedTableCells(&firstRow, &numRows, &firstColumn, &numColumns);
}

class MyQTextDocument: public QTextDocument
{
public:
	MyQTextDocument(const QString &text, QObject *parent) : QTextDocument(text, parent) {};
	MyQTextDocument(QObject *parent) : QTextDocument(parent) {};
	QTextObject * createObject(const QTextFormat & format) { return static_cast<QTextObject*>(callbackQTextDocument_CreateObject(this, const_cast<QTextFormat*>(&format))); };
	QVariant loadResource(int ty, const QUrl & name) { return *static_cast<QVariant*>(callbackQTextDocument_LoadResource(this, ty, const_cast<QUrl*>(&name))); };
	void Signal_BaseUrlChanged(const QUrl & url) { callbackQTextDocument_BaseUrlChanged(this, const_cast<QUrl*>(&url)); };
	void Signal_BlockCountChanged(int newBlockCount) { callbackQTextDocument_BlockCountChanged(this, newBlockCount); };
	void clear() { callbackQTextDocument_Clear(this); };
	void Signal_ContentsChange(int position, int charsRemoved, int charsAdded) { callbackQTextDocument_ContentsChange(this, position, charsRemoved, charsAdded); };
	void Signal_ContentsChanged() { callbackQTextDocument_ContentsChanged(this); };
	void Signal_CursorPositionChanged(const QTextCursor & cursor) { callbackQTextDocument_CursorPositionChanged(this, const_cast<QTextCursor*>(&cursor)); };
	void Signal_DocumentLayoutChanged() { callbackQTextDocument_DocumentLayoutChanged(this); };
	void Signal_ModificationChanged(bool changed) { callbackQTextDocument_ModificationChanged(this, changed); };
	void redo() { callbackQTextDocument_Redo2(this); };
	void Signal_RedoAvailable(bool available) { callbackQTextDocument_RedoAvailable(this, available); };
	void setModified(bool m) { callbackQTextDocument_SetModified(this, m); };
	void undo() { callbackQTextDocument_Undo2(this); };
	void Signal_UndoAvailable(bool available) { callbackQTextDocument_UndoAvailable(this, available); };
	void Signal_UndoCommandAdded() { callbackQTextDocument_UndoCommandAdded(this); };
	bool event(QEvent * e) { return callbackQTextDocument_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextDocument_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQTextDocument_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTextDocument_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTextDocument_CustomEvent(this, event); };
	void deleteLater() { callbackQTextDocument_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQTextDocument_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTextDocument_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextDocument_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQTextDocument_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextDocument_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QTextDocument_NewQTextDocument2(char* text, void* parent)
{
	return new MyQTextDocument(QString(text), static_cast<QObject*>(parent));
}

void* QTextDocument_CreateObject(void* ptr, void* format)
{
	return static_cast<QTextDocument*>(ptr)->createObject(*static_cast<QTextFormat*>(format));
}

void* QTextDocument_CreateObjectDefault(void* ptr, void* format)
{
		return static_cast<QTextDocument*>(ptr)->QTextDocument::createObject(*static_cast<QTextFormat*>(format));
}

void* QTextDocument_NewQTextDocument(void* parent)
{
	return new MyQTextDocument(static_cast<QObject*>(parent));
}

void* QTextDocument_LoadResource(void* ptr, int ty, void* name)
{
	return new QVariant(static_cast<QTextDocument*>(ptr)->loadResource(ty, *static_cast<QUrl*>(name)));
}

void* QTextDocument_LoadResourceDefault(void* ptr, int ty, void* name)
{
		return new QVariant(static_cast<QTextDocument*>(ptr)->QTextDocument::loadResource(ty, *static_cast<QUrl*>(name)));
}

void QTextDocument_AddResource(void* ptr, int ty, void* name, void* resource)
{
	static_cast<QTextDocument*>(ptr)->addResource(ty, *static_cast<QUrl*>(name), *static_cast<QVariant*>(resource));
}

void QTextDocument_AdjustSize(void* ptr)
{
	static_cast<QTextDocument*>(ptr)->adjustSize();
}

void QTextDocument_ConnectBaseUrlChanged(void* ptr)
{
	QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(const QUrl &)>(&QTextDocument::baseUrlChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(const QUrl &)>(&MyQTextDocument::Signal_BaseUrlChanged));
}

void QTextDocument_DisconnectBaseUrlChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(const QUrl &)>(&QTextDocument::baseUrlChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(const QUrl &)>(&MyQTextDocument::Signal_BaseUrlChanged));
}

void QTextDocument_BaseUrlChanged(void* ptr, void* url)
{
	static_cast<QTextDocument*>(ptr)->baseUrlChanged(*static_cast<QUrl*>(url));
}

void QTextDocument_ConnectBlockCountChanged(void* ptr)
{
	QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(int)>(&QTextDocument::blockCountChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(int)>(&MyQTextDocument::Signal_BlockCountChanged));
}

void QTextDocument_DisconnectBlockCountChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(int)>(&QTextDocument::blockCountChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(int)>(&MyQTextDocument::Signal_BlockCountChanged));
}

void QTextDocument_BlockCountChanged(void* ptr, int newBlockCount)
{
	static_cast<QTextDocument*>(ptr)->blockCountChanged(newBlockCount);
}

void QTextDocument_Clear(void* ptr)
{
	static_cast<QTextDocument*>(ptr)->clear();
}

void QTextDocument_ClearDefault(void* ptr)
{
		static_cast<QTextDocument*>(ptr)->QTextDocument::clear();
}

void QTextDocument_ClearUndoRedoStacks(void* ptr, long long stacksToClear)
{
	static_cast<QTextDocument*>(ptr)->clearUndoRedoStacks(static_cast<QTextDocument::Stacks>(stacksToClear));
}

void QTextDocument_ConnectContentsChange(void* ptr)
{
	QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(int, int, int)>(&QTextDocument::contentsChange), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(int, int, int)>(&MyQTextDocument::Signal_ContentsChange));
}

void QTextDocument_DisconnectContentsChange(void* ptr)
{
	QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(int, int, int)>(&QTextDocument::contentsChange), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(int, int, int)>(&MyQTextDocument::Signal_ContentsChange));
}

void QTextDocument_ContentsChange(void* ptr, int position, int charsRemoved, int charsAdded)
{
	static_cast<QTextDocument*>(ptr)->contentsChange(position, charsRemoved, charsAdded);
}

void QTextDocument_ConnectContentsChanged(void* ptr)
{
	QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::contentsChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_ContentsChanged));
}

void QTextDocument_DisconnectContentsChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::contentsChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_ContentsChanged));
}

void QTextDocument_ContentsChanged(void* ptr)
{
	static_cast<QTextDocument*>(ptr)->contentsChanged();
}

void QTextDocument_ConnectCursorPositionChanged(void* ptr)
{
	QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(const QTextCursor &)>(&QTextDocument::cursorPositionChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(const QTextCursor &)>(&MyQTextDocument::Signal_CursorPositionChanged));
}

void QTextDocument_DisconnectCursorPositionChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(const QTextCursor &)>(&QTextDocument::cursorPositionChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(const QTextCursor &)>(&MyQTextDocument::Signal_CursorPositionChanged));
}

void QTextDocument_CursorPositionChanged(void* ptr, void* cursor)
{
	static_cast<QTextDocument*>(ptr)->cursorPositionChanged(*static_cast<QTextCursor*>(cursor));
}

void QTextDocument_ConnectDocumentLayoutChanged(void* ptr)
{
	QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::documentLayoutChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_DocumentLayoutChanged));
}

void QTextDocument_DisconnectDocumentLayoutChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::documentLayoutChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_DocumentLayoutChanged));
}

void QTextDocument_DocumentLayoutChanged(void* ptr)
{
	static_cast<QTextDocument*>(ptr)->documentLayoutChanged();
}

void QTextDocument_DrawContents(void* ptr, void* p, void* rect)
{
	static_cast<QTextDocument*>(ptr)->drawContents(static_cast<QPainter*>(p), *static_cast<QRectF*>(rect));
}

void QTextDocument_MarkContentsDirty(void* ptr, int position, int length)
{
	static_cast<QTextDocument*>(ptr)->markContentsDirty(position, length);
}

void QTextDocument_ConnectModificationChanged(void* ptr)
{
	QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::modificationChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_ModificationChanged));
}

void QTextDocument_DisconnectModificationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::modificationChanged), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_ModificationChanged));
}

void QTextDocument_ModificationChanged(void* ptr, char changed)
{
	static_cast<QTextDocument*>(ptr)->modificationChanged(changed != 0);
}

void QTextDocument_Redo2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextDocument*>(ptr), "redo");
}

void QTextDocument_Redo2Default(void* ptr)
{
		static_cast<QTextDocument*>(ptr)->QTextDocument::redo();
}

void QTextDocument_Redo(void* ptr, void* cursor)
{
	static_cast<QTextDocument*>(ptr)->redo(static_cast<QTextCursor*>(cursor));
}

void QTextDocument_ConnectRedoAvailable(void* ptr)
{
	QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::redoAvailable), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_RedoAvailable));
}

void QTextDocument_DisconnectRedoAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::redoAvailable), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_RedoAvailable));
}

void QTextDocument_RedoAvailable(void* ptr, char available)
{
	static_cast<QTextDocument*>(ptr)->redoAvailable(available != 0);
}

void QTextDocument_SetBaseUrl(void* ptr, void* url)
{
	static_cast<QTextDocument*>(ptr)->setBaseUrl(*static_cast<QUrl*>(url));
}

void QTextDocument_SetDefaultCursorMoveStyle(void* ptr, long long style)
{
	static_cast<QTextDocument*>(ptr)->setDefaultCursorMoveStyle(static_cast<Qt::CursorMoveStyle>(style));
}

void QTextDocument_SetDefaultFont(void* ptr, void* font)
{
	static_cast<QTextDocument*>(ptr)->setDefaultFont(*static_cast<QFont*>(font));
}

void QTextDocument_SetDefaultStyleSheet(void* ptr, char* sheet)
{
	static_cast<QTextDocument*>(ptr)->setDefaultStyleSheet(QString(sheet));
}

void QTextDocument_SetDefaultTextOption(void* ptr, void* option)
{
	static_cast<QTextDocument*>(ptr)->setDefaultTextOption(*static_cast<QTextOption*>(option));
}

void QTextDocument_SetDocumentLayout(void* ptr, void* layout)
{
	static_cast<QTextDocument*>(ptr)->setDocumentLayout(static_cast<QAbstractTextDocumentLayout*>(layout));
}

void QTextDocument_SetDocumentMargin(void* ptr, double margin)
{
	static_cast<QTextDocument*>(ptr)->setDocumentMargin(margin);
}

void QTextDocument_SetHtml(void* ptr, char* html)
{
	static_cast<QTextDocument*>(ptr)->setHtml(QString(html));
}

void QTextDocument_SetIndentWidth(void* ptr, double width)
{
	static_cast<QTextDocument*>(ptr)->setIndentWidth(width);
}

void QTextDocument_SetMaximumBlockCount(void* ptr, int maximum)
{
	static_cast<QTextDocument*>(ptr)->setMaximumBlockCount(maximum);
}

void QTextDocument_SetMetaInformation(void* ptr, long long info, char* stri)
{
	static_cast<QTextDocument*>(ptr)->setMetaInformation(static_cast<QTextDocument::MetaInformation>(info), QString(stri));
}

void QTextDocument_SetModified(void* ptr, char m)
{
	QMetaObject::invokeMethod(static_cast<QTextDocument*>(ptr), "setModified", Q_ARG(bool, m != 0));
}

void QTextDocument_SetModifiedDefault(void* ptr, char m)
{
		static_cast<QTextDocument*>(ptr)->QTextDocument::setModified(m != 0);
}

void QTextDocument_SetPageSize(void* ptr, void* size)
{
	static_cast<QTextDocument*>(ptr)->setPageSize(*static_cast<QSizeF*>(size));
}

void QTextDocument_SetPlainText(void* ptr, char* text)
{
	static_cast<QTextDocument*>(ptr)->setPlainText(QString(text));
}

void QTextDocument_SetTextWidth(void* ptr, double width)
{
	static_cast<QTextDocument*>(ptr)->setTextWidth(width);
}

void QTextDocument_SetUndoRedoEnabled(void* ptr, char enable)
{
	static_cast<QTextDocument*>(ptr)->setUndoRedoEnabled(enable != 0);
}

void QTextDocument_SetUseDesignMetrics(void* ptr, char b)
{
	static_cast<QTextDocument*>(ptr)->setUseDesignMetrics(b != 0);
}

void QTextDocument_Undo2(void* ptr)
{
	QMetaObject::invokeMethod(static_cast<QTextDocument*>(ptr), "undo");
}

void QTextDocument_Undo2Default(void* ptr)
{
		static_cast<QTextDocument*>(ptr)->QTextDocument::undo();
}

void QTextDocument_Undo(void* ptr, void* cursor)
{
	static_cast<QTextDocument*>(ptr)->undo(static_cast<QTextCursor*>(cursor));
}

void QTextDocument_ConnectUndoAvailable(void* ptr)
{
	QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::undoAvailable), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_UndoAvailable));
}

void QTextDocument_DisconnectUndoAvailable(void* ptr)
{
	QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)(bool)>(&QTextDocument::undoAvailable), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)(bool)>(&MyQTextDocument::Signal_UndoAvailable));
}

void QTextDocument_UndoAvailable(void* ptr, char available)
{
	static_cast<QTextDocument*>(ptr)->undoAvailable(available != 0);
}

void QTextDocument_ConnectUndoCommandAdded(void* ptr)
{
	QObject::connect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::undoCommandAdded), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_UndoCommandAdded));
}

void QTextDocument_DisconnectUndoCommandAdded(void* ptr)
{
	QObject::disconnect(static_cast<QTextDocument*>(ptr), static_cast<void (QTextDocument::*)()>(&QTextDocument::undoCommandAdded), static_cast<MyQTextDocument*>(ptr), static_cast<void (MyQTextDocument::*)()>(&MyQTextDocument::Signal_UndoCommandAdded));
}

void QTextDocument_UndoCommandAdded(void* ptr)
{
	static_cast<QTextDocument*>(ptr)->undoCommandAdded();
}

void QTextDocument_DestroyQTextDocument(void* ptr)
{
	static_cast<QTextDocument*>(ptr)->~QTextDocument();
}

void* QTextDocument_DocumentLayout(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->documentLayout();
}

void* QTextDocument_CharacterAt(void* ptr, int pos)
{
	return new QChar(static_cast<QTextDocument*>(ptr)->characterAt(pos));
}

void* QTextDocument_DefaultFont(void* ptr)
{
	return new QFont(static_cast<QTextDocument*>(ptr)->defaultFont());
}

void* QTextDocument_PageSize(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QTextDocument*>(ptr)->pageSize(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void* QTextDocument_Size(void* ptr)
{
	return ({ QSizeF tmpValue = static_cast<QTextDocument*>(ptr)->size(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QTextDocument_DefaultStyleSheet(void* ptr)
{
	return ({ QByteArray t95f0f4 = static_cast<QTextDocument*>(ptr)->defaultStyleSheet().toUtf8(); QtGui_PackedString { const_cast<char*>(t95f0f4.prepend("WHITESPACE").constData()+10), t95f0f4.size()-10 }; });
}

struct QtGui_PackedString QTextDocument_MetaInformation(void* ptr, long long info)
{
	return ({ QByteArray ta91ae2 = static_cast<QTextDocument*>(ptr)->metaInformation(static_cast<QTextDocument::MetaInformation>(info)).toUtf8(); QtGui_PackedString { const_cast<char*>(ta91ae2.prepend("WHITESPACE").constData()+10), ta91ae2.size()-10 }; });
}

struct QtGui_PackedString QTextDocument_ToHtml(void* ptr, void* encoding)
{
	return ({ QByteArray t48be10 = static_cast<QTextDocument*>(ptr)->toHtml(*static_cast<QByteArray*>(encoding)).toUtf8(); QtGui_PackedString { const_cast<char*>(t48be10.prepend("WHITESPACE").constData()+10), t48be10.size()-10 }; });
}

struct QtGui_PackedString QTextDocument_ToPlainText(void* ptr)
{
	return ({ QByteArray t7d8da3 = static_cast<QTextDocument*>(ptr)->toPlainText().toUtf8(); QtGui_PackedString { const_cast<char*>(t7d8da3.prepend("WHITESPACE").constData()+10), t7d8da3.size()-10 }; });
}

void* QTextDocument_Begin(void* ptr)
{
	return new QTextBlock(static_cast<QTextDocument*>(ptr)->begin());
}

void* QTextDocument_End(void* ptr)
{
	return new QTextBlock(static_cast<QTextDocument*>(ptr)->end());
}

void* QTextDocument_FindBlock(void* ptr, int pos)
{
	return new QTextBlock(static_cast<QTextDocument*>(ptr)->findBlock(pos));
}

void* QTextDocument_FindBlockByLineNumber(void* ptr, int lineNumber)
{
	return new QTextBlock(static_cast<QTextDocument*>(ptr)->findBlockByLineNumber(lineNumber));
}

void* QTextDocument_FindBlockByNumber(void* ptr, int blockNumber)
{
	return new QTextBlock(static_cast<QTextDocument*>(ptr)->findBlockByNumber(blockNumber));
}

void* QTextDocument_FirstBlock(void* ptr)
{
	return new QTextBlock(static_cast<QTextDocument*>(ptr)->firstBlock());
}

void* QTextDocument_LastBlock(void* ptr)
{
	return new QTextBlock(static_cast<QTextDocument*>(ptr)->lastBlock());
}

void* QTextDocument_Find4(void* ptr, void* expr, void* cursor, long long options)
{
	return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(*static_cast<QRegExp*>(expr), *static_cast<QTextCursor*>(cursor), static_cast<QTextDocument::FindFlag>(options)));
}

void* QTextDocument_Find3(void* ptr, void* expr, int from, long long options)
{
	return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(*static_cast<QRegExp*>(expr), from, static_cast<QTextDocument::FindFlag>(options)));
}

void* QTextDocument_Find6(void* ptr, void* expr, void* cursor, long long options)
{
	return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(*static_cast<QRegularExpression*>(expr), *static_cast<QTextCursor*>(cursor), static_cast<QTextDocument::FindFlag>(options)));
}

void* QTextDocument_Find5(void* ptr, void* expr, int from, long long options)
{
	return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(*static_cast<QRegularExpression*>(expr), from, static_cast<QTextDocument::FindFlag>(options)));
}

void* QTextDocument_Find(void* ptr, char* subString, void* cursor, long long options)
{
	return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(QString(subString), *static_cast<QTextCursor*>(cursor), static_cast<QTextDocument::FindFlag>(options)));
}

void* QTextDocument_Find2(void* ptr, char* subString, int position, long long options)
{
	return new QTextCursor(static_cast<QTextDocument*>(ptr)->find(QString(subString), position, static_cast<QTextDocument::FindFlag>(options)));
}

void* QTextDocument_Clone(void* ptr, void* parent)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
		return static_cast<QTextDocument*>(ptr)->clone(static_cast<QOffscreenSurface*>(parent));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
		return static_cast<QTextDocument*>(ptr)->clone(static_cast<QPaintDeviceWindow*>(parent));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
		return static_cast<QTextDocument*>(ptr)->clone(static_cast<QPdfWriter*>(parent));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
		return static_cast<QTextDocument*>(ptr)->clone(static_cast<QWindow*>(parent));
	} else {
		return static_cast<QTextDocument*>(ptr)->clone(static_cast<QObject*>(parent));
	}
}

void* QTextDocument_RootFrame(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->rootFrame();
}

void* QTextDocument_Object(void* ptr, int objectIndex)
{
	return static_cast<QTextDocument*>(ptr)->object(objectIndex);
}

void* QTextDocument_ObjectForFormat(void* ptr, void* f)
{
	return static_cast<QTextDocument*>(ptr)->objectForFormat(*static_cast<QTextFormat*>(f));
}

void* QTextDocument_DefaultTextOption(void* ptr)
{
	return new QTextOption(static_cast<QTextDocument*>(ptr)->defaultTextOption());
}

void* QTextDocument_BaseUrl(void* ptr)
{
	return new QUrl(static_cast<QTextDocument*>(ptr)->baseUrl());
}

void* QTextDocument_Resource(void* ptr, int ty, void* name)
{
	return new QVariant(static_cast<QTextDocument*>(ptr)->resource(ty, *static_cast<QUrl*>(name)));
}

struct QtGui_PackedList QTextDocument_AllFormats(void* ptr)
{
	return ({ QVector<QTextFormat>* tmpValue = new QVector<QTextFormat>(static_cast<QTextDocument*>(ptr)->allFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

long long QTextDocument_DefaultCursorMoveStyle(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->defaultCursorMoveStyle();
}

char QTextDocument_IsEmpty(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->isEmpty();
}

char QTextDocument_IsModified(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->isModified();
}

char QTextDocument_IsRedoAvailable(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->isRedoAvailable();
}

char QTextDocument_IsUndoAvailable(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->isUndoAvailable();
}

char QTextDocument_IsUndoRedoEnabled(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->isUndoRedoEnabled();
}

char QTextDocument_UseDesignMetrics(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->useDesignMetrics();
}

int QTextDocument_AvailableRedoSteps(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->availableRedoSteps();
}

int QTextDocument_AvailableUndoSteps(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->availableUndoSteps();
}

int QTextDocument_BlockCount(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->blockCount();
}

int QTextDocument_CharacterCount(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->characterCount();
}

int QTextDocument_LineCount(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->lineCount();
}

int QTextDocument_MaximumBlockCount(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->maximumBlockCount();
}

int QTextDocument_PageCount(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->pageCount();
}

int QTextDocument_Revision(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->revision();
}

double QTextDocument_DocumentMargin(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->documentMargin();
}

double QTextDocument_IdealWidth(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->idealWidth();
}

double QTextDocument_IndentWidth(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->indentWidth();
}

double QTextDocument_TextWidth(void* ptr)
{
	return static_cast<QTextDocument*>(ptr)->textWidth();
}

void QTextDocument_Print(void* ptr, void* printer)
{
#ifndef Q_OS_IOS
	if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(printer))) {
		static_cast<QTextDocument*>(ptr)->print(static_cast<QPdfWriter*>(printer));
	} else {
		static_cast<QTextDocument*>(ptr)->print(static_cast<QPagedPaintDevice*>(printer));
	}
#endif
}

void* QTextDocument___allFormats_atList(void* ptr, int i)
{
	return new QTextFormat(static_cast<QVector<QTextFormat>*>(ptr)->at(i));
}

void QTextDocument___allFormats_setList(void* ptr, void* i)
{
	static_cast<QVector<QTextFormat>*>(ptr)->append(*static_cast<QTextFormat*>(i));
}

void* QTextDocument___allFormats_newList(void* ptr)
{
	return new QVector<QTextFormat>;
}

void* QTextDocument___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QTextDocument___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QTextDocument___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QTextDocument___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QTextDocument___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QTextDocument___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QTextDocument___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QTextDocument___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QTextDocument___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QTextDocument___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QTextDocument___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QTextDocument___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QTextDocument___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QTextDocument___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QTextDocument___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QTextDocument_EventDefault(void* ptr, void* e)
{
		return static_cast<QTextDocument*>(ptr)->QTextDocument::event(static_cast<QEvent*>(e));
}

char QTextDocument_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
		return static_cast<QTextDocument*>(ptr)->QTextDocument::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QTextDocument*>(ptr)->QTextDocument::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
		return static_cast<QTextDocument*>(ptr)->QTextDocument::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
		return static_cast<QTextDocument*>(ptr)->QTextDocument::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
	} else {
		return static_cast<QTextDocument*>(ptr)->QTextDocument::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
	}
}

void QTextDocument_ChildEventDefault(void* ptr, void* event)
{
		static_cast<QTextDocument*>(ptr)->QTextDocument::childEvent(static_cast<QChildEvent*>(event));
}

void QTextDocument_ConnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QTextDocument*>(ptr)->QTextDocument::connectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTextDocument_CustomEventDefault(void* ptr, void* event)
{
		static_cast<QTextDocument*>(ptr)->QTextDocument::customEvent(static_cast<QEvent*>(event));
}

void QTextDocument_DeleteLaterDefault(void* ptr)
{
		static_cast<QTextDocument*>(ptr)->QTextDocument::deleteLater();
}

void QTextDocument_DisconnectNotifyDefault(void* ptr, void* sign)
{
		static_cast<QTextDocument*>(ptr)->QTextDocument::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}

void QTextDocument_TimerEventDefault(void* ptr, void* event)
{
		static_cast<QTextDocument*>(ptr)->QTextDocument::timerEvent(static_cast<QTimerEvent*>(event));
}

void* QTextDocument_MetaObjectDefault(void* ptr)
{
		return const_cast<QMetaObject*>(static_cast<QTextDocument*>(ptr)->QTextDocument::metaObject());
}

void* QTextDocumentFragment_QTextDocumentFragment_FromHtml(char* text)
{
	return new QTextDocumentFragment(QTextDocumentFragment::fromHtml(QString(text)));
}

void* QTextDocumentFragment_QTextDocumentFragment_FromHtml2(char* text, void* resourceProvider)
{
	return new QTextDocumentFragment(QTextDocumentFragment::fromHtml(QString(text), static_cast<QTextDocument*>(resourceProvider)));
}

void* QTextDocumentFragment_QTextDocumentFragment_FromPlainText(char* plainText)
{
	return new QTextDocumentFragment(QTextDocumentFragment::fromPlainText(QString(plainText)));
}

void* QTextDocumentFragment_NewQTextDocumentFragment()
{
	return new QTextDocumentFragment();
}

void* QTextDocumentFragment_NewQTextDocumentFragment3(void* cursor)
{
	return new QTextDocumentFragment(*static_cast<QTextCursor*>(cursor));
}

void* QTextDocumentFragment_NewQTextDocumentFragment2(void* document)
{
	return new QTextDocumentFragment(static_cast<QTextDocument*>(document));
}

void* QTextDocumentFragment_NewQTextDocumentFragment4(void* other)
{
	return new QTextDocumentFragment(*static_cast<QTextDocumentFragment*>(other));
}

void QTextDocumentFragment_DestroyQTextDocumentFragment(void* ptr)
{
	static_cast<QTextDocumentFragment*>(ptr)->~QTextDocumentFragment();
}

struct QtGui_PackedString QTextDocumentFragment_ToHtml(void* ptr, void* encoding)
{
	return ({ QByteArray t6dea0f = static_cast<QTextDocumentFragment*>(ptr)->toHtml(*static_cast<QByteArray*>(encoding)).toUtf8(); QtGui_PackedString { const_cast<char*>(t6dea0f.prepend("WHITESPACE").constData()+10), t6dea0f.size()-10 }; });
}

struct QtGui_PackedString QTextDocumentFragment_ToPlainText(void* ptr)
{
	return ({ QByteArray td3666e = static_cast<QTextDocumentFragment*>(ptr)->toPlainText().toUtf8(); QtGui_PackedString { const_cast<char*>(td3666e.prepend("WHITESPACE").constData()+10), td3666e.size()-10 }; });
}

char QTextDocumentFragment_IsEmpty(void* ptr)
{
	return static_cast<QTextDocumentFragment*>(ptr)->isEmpty();
}

struct QtGui_PackedList QTextDocumentWriter_QTextDocumentWriter_SupportedDocumentFormats()
{
	return ({ QList<QByteArray>* tmpValue = new QList<QByteArray>(QTextDocumentWriter::supportedDocumentFormats()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QTextDocumentWriter_NewQTextDocumentWriter()
{
	return new QTextDocumentWriter();
}

void* QTextDocumentWriter_NewQTextDocumentWriter2(void* device, void* format)
{
	return new QTextDocumentWriter(static_cast<QIODevice*>(device), *static_cast<QByteArray*>(format));
}

void* QTextDocumentWriter_NewQTextDocumentWriter3(char* fileName, void* format)
{
	return new QTextDocumentWriter(QString(fileName), *static_cast<QByteArray*>(format));
}

char QTextDocumentWriter_Write(void* ptr, void* document)
{
	return static_cast<QTextDocumentWriter*>(ptr)->write(static_cast<QTextDocument*>(document));
}

char QTextDocumentWriter_Write2(void* ptr, void* fragment)
{
	return static_cast<QTextDocumentWriter*>(ptr)->write(*static_cast<QTextDocumentFragment*>(fragment));
}

void QTextDocumentWriter_SetCodec(void* ptr, void* codec)
{
	static_cast<QTextDocumentWriter*>(ptr)->setCodec(static_cast<QTextCodec*>(codec));
}

void QTextDocumentWriter_SetDevice(void* ptr, void* device)
{
	static_cast<QTextDocumentWriter*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}

void QTextDocumentWriter_SetFileName(void* ptr, char* fileName)
{
	static_cast<QTextDocumentWriter*>(ptr)->setFileName(QString(fileName));
}

void QTextDocumentWriter_SetFormat(void* ptr, void* format)
{
	static_cast<QTextDocumentWriter*>(ptr)->setFormat(*static_cast<QByteArray*>(format));
}

void QTextDocumentWriter_DestroyQTextDocumentWriter(void* ptr)
{
	static_cast<QTextDocumentWriter*>(ptr)->~QTextDocumentWriter();
}

void* QTextDocumentWriter_Format(void* ptr)
{
	return new QByteArray(static_cast<QTextDocumentWriter*>(ptr)->format());
}

void* QTextDocumentWriter_Device(void* ptr)
{
	return static_cast<QTextDocumentWriter*>(ptr)->device();
}

struct QtGui_PackedString QTextDocumentWriter_FileName(void* ptr)
{
	return ({ QByteArray tbc6b5c = static_cast<QTextDocumentWriter*>(ptr)->fileName().toUtf8(); QtGui_PackedString { const_cast<char*>(tbc6b5c.prepend("WHITESPACE").constData()+10), tbc6b5c.size()-10 }; });
}

void* QTextDocumentWriter_Codec(void* ptr)
{
	return static_cast<QTextDocumentWriter*>(ptr)->codec();
}

void* QTextDocumentWriter___supportedDocumentFormats_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QTextDocumentWriter___supportedDocumentFormats_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QTextDocumentWriter___supportedDocumentFormats_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QTextFormat_NewQTextFormat3(void* other)
{
	return new QTextFormat(*static_cast<QTextFormat*>(other));
}

void* QTextFormat_NewQTextFormat()
{
	return new QTextFormat();
}

void* QTextFormat_NewQTextFormat2(int ty)
{
	return new QTextFormat(ty);
}

void QTextFormat_ClearBackground(void* ptr)
{
	static_cast<QTextFormat*>(ptr)->clearBackground();
}

void QTextFormat_ClearForeground(void* ptr)
{
	static_cast<QTextFormat*>(ptr)->clearForeground();
}

void QTextFormat_ClearProperty(void* ptr, int propertyId)
{
	static_cast<QTextFormat*>(ptr)->clearProperty(propertyId);
}

void QTextFormat_Merge(void* ptr, void* other)
{
	static_cast<QTextFormat*>(ptr)->merge(*static_cast<QTextFormat*>(other));
}

void QTextFormat_SetBackground(void* ptr, void* brush)
{
	static_cast<QTextFormat*>(ptr)->setBackground(*static_cast<QBrush*>(brush));
}

void QTextFormat_SetForeground(void* ptr, void* brush)
{
	static_cast<QTextFormat*>(ptr)->setForeground(*static_cast<QBrush*>(brush));
}

void QTextFormat_SetLayoutDirection(void* ptr, long long direction)
{
	static_cast<QTextFormat*>(ptr)->setLayoutDirection(static_cast<Qt::LayoutDirection>(direction));
}

void QTextFormat_SetObjectIndex(void* ptr, int index)
{
	static_cast<QTextFormat*>(ptr)->setObjectIndex(index);
}

void QTextFormat_SetObjectType(void* ptr, int ty)
{
	static_cast<QTextFormat*>(ptr)->setObjectType(ty);
}

void QTextFormat_SetProperty(void* ptr, int propertyId, void* value)
{
	static_cast<QTextFormat*>(ptr)->setProperty(propertyId, *static_cast<QVariant*>(value));
}

void QTextFormat_SetProperty2(void* ptr, int propertyId, void* value)
{
	static_cast<QTextFormat*>(ptr)->setProperty(propertyId, *static_cast<QVector<QTextLength>*>(value));
}

void QTextFormat_Swap(void* ptr, void* other)
{
	static_cast<QTextFormat*>(ptr)->swap(*static_cast<QTextFormat*>(other));
}

void QTextFormat_DestroyQTextFormat(void* ptr)
{
	static_cast<QTextFormat*>(ptr)->~QTextFormat();
}

void* QTextFormat_Background(void* ptr)
{
	return new QBrush(static_cast<QTextFormat*>(ptr)->background());
}

void* QTextFormat_BrushProperty(void* ptr, int propertyId)
{
	return new QBrush(static_cast<QTextFormat*>(ptr)->brushProperty(propertyId));
}

void* QTextFormat_Foreground(void* ptr)
{
	return new QBrush(static_cast<QTextFormat*>(ptr)->foreground());
}

void* QTextFormat_ColorProperty(void* ptr, int propertyId)
{
	return new QColor(static_cast<QTextFormat*>(ptr)->colorProperty(propertyId));
}

struct QtGui_PackedList QTextFormat_Properties(void* ptr)
{
	return ({ QMap<int, QVariant>* tmpValue = new QMap<int, QVariant>(static_cast<QTextFormat*>(ptr)->properties()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QTextFormat_PenProperty(void* ptr, int propertyId)
{
	return new QPen(static_cast<QTextFormat*>(ptr)->penProperty(propertyId));
}

struct QtGui_PackedString QTextFormat_StringProperty(void* ptr, int propertyId)
{
	return ({ QByteArray tb40d27 = static_cast<QTextFormat*>(ptr)->stringProperty(propertyId).toUtf8(); QtGui_PackedString { const_cast<char*>(tb40d27.prepend("WHITESPACE").constData()+10), tb40d27.size()-10 }; });
}

void* QTextFormat_ToBlockFormat(void* ptr)
{
	return new QTextBlockFormat(static_cast<QTextFormat*>(ptr)->toBlockFormat());
}

void* QTextFormat_ToCharFormat(void* ptr)
{
	return new QTextCharFormat(static_cast<QTextFormat*>(ptr)->toCharFormat());
}

void* QTextFormat_ToFrameFormat(void* ptr)
{
	return new QTextFrameFormat(static_cast<QTextFormat*>(ptr)->toFrameFormat());
}

void* QTextFormat_ToImageFormat(void* ptr)
{
	return new QTextImageFormat(static_cast<QTextFormat*>(ptr)->toImageFormat());
}

void* QTextFormat_LengthProperty(void* ptr, int propertyId)
{
	return new QTextLength(static_cast<QTextFormat*>(ptr)->lengthProperty(propertyId));
}

void* QTextFormat_ToListFormat(void* ptr)
{
	return new QTextListFormat(static_cast<QTextFormat*>(ptr)->toListFormat());
}

void* QTextFormat_ToTableCellFormat(void* ptr)
{
	return new QTextTableCellFormat(static_cast<QTextFormat*>(ptr)->toTableCellFormat());
}

void* QTextFormat_ToTableFormat(void* ptr)
{
	return new QTextTableFormat(static_cast<QTextFormat*>(ptr)->toTableFormat());
}

void* QTextFormat_Property(void* ptr, int propertyId)
{
	return new QVariant(static_cast<QTextFormat*>(ptr)->property(propertyId));
}

long long QTextFormat_LayoutDirection(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->layoutDirection();
}

char QTextFormat_BoolProperty(void* ptr, int propertyId)
{
	return static_cast<QTextFormat*>(ptr)->boolProperty(propertyId);
}

char QTextFormat_HasProperty(void* ptr, int propertyId)
{
	return static_cast<QTextFormat*>(ptr)->hasProperty(propertyId);
}

char QTextFormat_IsBlockFormat(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->isBlockFormat();
}

char QTextFormat_IsCharFormat(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->isCharFormat();
}

char QTextFormat_IsEmpty(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->isEmpty();
}

char QTextFormat_IsFrameFormat(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->isFrameFormat();
}

char QTextFormat_IsImageFormat(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->isImageFormat();
}

char QTextFormat_IsListFormat(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->isListFormat();
}

char QTextFormat_IsTableCellFormat(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->isTableCellFormat();
}

char QTextFormat_IsTableFormat(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->isTableFormat();
}

char QTextFormat_IsValid(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->isValid();
}

int QTextFormat_IntProperty(void* ptr, int propertyId)
{
	return static_cast<QTextFormat*>(ptr)->intProperty(propertyId);
}

int QTextFormat_ObjectIndex(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->objectIndex();
}

int QTextFormat_ObjectType(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->objectType();
}

int QTextFormat_PropertyCount(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->propertyCount();
}

int QTextFormat_Type(void* ptr)
{
	return static_cast<QTextFormat*>(ptr)->type();
}

double QTextFormat_DoubleProperty(void* ptr, int propertyId)
{
	return static_cast<QTextFormat*>(ptr)->doubleProperty(propertyId);
}

void* QTextFormat___setProperty_value_atList2(void* ptr, int i)
{
	return new QTextLength(static_cast<QVector<QTextLength>*>(ptr)->at(i));
}

void QTextFormat___setProperty_value_setList2(void* ptr, void* i)
{
	static_cast<QVector<QTextLength>*>(ptr)->append(*static_cast<QTextLength*>(i));
}

void* QTextFormat___setProperty_value_newList2(void* ptr)
{
	return new QVector<QTextLength>;
}

void* QTextFormat___properties_atList(void* ptr, int i)
{
	return new QVariant(static_cast<QMap<int, QVariant>*>(ptr)->value(i));
}

void QTextFormat___properties_setList(void* ptr, int key, void* i)
{
	static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}

void* QTextFormat___properties_newList(void* ptr)
{
	return new QMap<int, QVariant>;
}

struct QtGui_PackedList QTextFormat___properties_keyList(void* ptr)
{
	return ({ QList<int>* tmpValue = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QTextFormat___lengthVectorProperty_atList(void* ptr, int i)
{
	return new QTextLength(static_cast<QVector<QTextLength>*>(ptr)->at(i));
}

void QTextFormat___lengthVectorProperty_setList(void* ptr, void* i)
{
	static_cast<QVector<QTextLength>*>(ptr)->append(*static_cast<QTextLength*>(i));
}

void* QTextFormat___lengthVectorProperty_newList(void* ptr)
{
	return new QVector<QTextLength>;
}

int QTextFormat_____properties_keyList_atList(void* ptr, int i)
{
	return static_cast<QList<int>*>(ptr)->at(i);
}

void QTextFormat_____properties_keyList_setList(void* ptr, int i)
{
	static_cast<QList<int>*>(ptr)->append(i);
}

void* QTextFormat_____properties_keyList_newList(void* ptr)
{
	return new QList<int>;
}

void* QTextFragment_NewQTextFragment()
{
	return new QTextFragment();
}

void* QTextFragment_NewQTextFragment3(void* other)
{
	return new QTextFragment(*static_cast<QTextFragment*>(other));
}

struct QtGui_PackedList QTextFragment_GlyphRuns(void* ptr, int pos, int len)
{
	return ({ QList<QGlyphRun>* tmpValue = new QList<QGlyphRun>(static_cast<QTextFragment*>(ptr)->glyphRuns(pos, len)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

struct QtGui_PackedString QTextFragment_Text(void* ptr)
{
	return ({ QByteArray t644af9 = static_cast<QTextFragment*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(t644af9.prepend("WHITESPACE").constData()+10), t644af9.size()-10 }; });
}

void* QTextFragment_CharFormat(void* ptr)
{
	return new QTextCharFormat(static_cast<QTextFragment*>(ptr)->charFormat());
}

char QTextFragment_Contains(void* ptr, int position)
{
	return static_cast<QTextFragment*>(ptr)->contains(position);
}

char QTextFragment_IsValid(void* ptr)
{
	return static_cast<QTextFragment*>(ptr)->isValid();
}

int QTextFragment_CharFormatIndex(void* ptr)
{
	return static_cast<QTextFragment*>(ptr)->charFormatIndex();
}

int QTextFragment_Length(void* ptr)
{
	return static_cast<QTextFragment*>(ptr)->length();
}

int QTextFragment_Position(void* ptr)
{
	return static_cast<QTextFragment*>(ptr)->position();
}

void* QTextFragment___glyphRuns_atList(void* ptr, int i)
{
	return new QGlyphRun(static_cast<QList<QGlyphRun>*>(ptr)->at(i));
}

void QTextFragment___glyphRuns_setList(void* ptr, void* i)
{
	static_cast<QList<QGlyphRun>*>(ptr)->append(*static_cast<QGlyphRun*>(i));
}

void* QTextFragment___glyphRuns_newList(void* ptr)
{
	return new QList<QGlyphRun>;
}

class MyQTextFrame: public QTextFrame
{
public:
	MyQTextFrame(QTextDocument *document) : QTextFrame(document) {};
	bool event(QEvent * e) { return callbackQTextObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextObject_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQTextObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTextObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTextObject_CustomEvent(this, event); };
	void deleteLater() { callbackQTextObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQTextObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTextObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQTextObject_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QTextFrame_NewQTextFrame(void* document)
{
	return new MyQTextFrame(static_cast<QTextDocument*>(document));
}

void QTextFrame_SetFrameFormat(void* ptr, void* format)
{
	static_cast<QTextFrame*>(ptr)->setFrameFormat(*static_cast<QTextFrameFormat*>(format));
}

void QTextFrame_DestroyQTextFrame(void* ptr)
{
	static_cast<QTextFrame*>(ptr)->~QTextFrame();
}

struct QtGui_PackedList QTextFrame_ChildFrames(void* ptr)
{
	return ({ QList<QTextFrame *>* tmpValue = new QList<QTextFrame *>(static_cast<QTextFrame*>(ptr)->childFrames()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QTextFrame_FirstCursorPosition(void* ptr)
{
	return new QTextCursor(static_cast<QTextFrame*>(ptr)->firstCursorPosition());
}

void* QTextFrame_LastCursorPosition(void* ptr)
{
	return new QTextCursor(static_cast<QTextFrame*>(ptr)->lastCursorPosition());
}

void* QTextFrame_ParentFrame(void* ptr)
{
	return static_cast<QTextFrame*>(ptr)->parentFrame();
}

void* QTextFrame_FrameFormat(void* ptr)
{
	return new QTextFrameFormat(static_cast<QTextFrame*>(ptr)->frameFormat());
}

int QTextFrame_FirstPosition(void* ptr)
{
	return static_cast<QTextFrame*>(ptr)->firstPosition();
}

int QTextFrame_LastPosition(void* ptr)
{
	return static_cast<QTextFrame*>(ptr)->lastPosition();
}

void* QTextFrame___childFrames_atList(void* ptr, int i)
{
	return const_cast<QTextFrame*>(static_cast<QList<QTextFrame *>*>(ptr)->at(i));
}

void QTextFrame___childFrames_setList(void* ptr, void* i)
{
	static_cast<QList<QTextFrame *>*>(ptr)->append(static_cast<QTextFrame*>(i));
}

void* QTextFrame___childFrames_newList(void* ptr)
{
	return new QList<QTextFrame *>;
}

void* QTextFrameFormat_NewQTextFrameFormat()
{
	return new QTextFrameFormat();
}

void QTextFrameFormat_SetBorder(void* ptr, double width)
{
	static_cast<QTextFrameFormat*>(ptr)->setBorder(width);
}

void QTextFrameFormat_SetBorderBrush(void* ptr, void* brush)
{
	static_cast<QTextFrameFormat*>(ptr)->setBorderBrush(*static_cast<QBrush*>(brush));
}

void QTextFrameFormat_SetBorderStyle(void* ptr, long long style)
{
	static_cast<QTextFrameFormat*>(ptr)->setBorderStyle(static_cast<QTextFrameFormat::BorderStyle>(style));
}

void QTextFrameFormat_SetBottomMargin(void* ptr, double margin)
{
	static_cast<QTextFrameFormat*>(ptr)->setBottomMargin(margin);
}

void QTextFrameFormat_SetHeight(void* ptr, void* height)
{
	static_cast<QTextFrameFormat*>(ptr)->setHeight(*static_cast<QTextLength*>(height));
}

void QTextFrameFormat_SetHeight2(void* ptr, double height)
{
	static_cast<QTextFrameFormat*>(ptr)->setHeight(height);
}

void QTextFrameFormat_SetLeftMargin(void* ptr, double margin)
{
	static_cast<QTextFrameFormat*>(ptr)->setLeftMargin(margin);
}

void QTextFrameFormat_SetMargin(void* ptr, double margin)
{
	static_cast<QTextFrameFormat*>(ptr)->setMargin(margin);
}

void QTextFrameFormat_SetPadding(void* ptr, double width)
{
	static_cast<QTextFrameFormat*>(ptr)->setPadding(width);
}

void QTextFrameFormat_SetPageBreakPolicy(void* ptr, long long policy)
{
	static_cast<QTextFrameFormat*>(ptr)->setPageBreakPolicy(static_cast<QTextFormat::PageBreakFlag>(policy));
}

void QTextFrameFormat_SetPosition(void* ptr, long long policy)
{
	static_cast<QTextFrameFormat*>(ptr)->setPosition(static_cast<QTextFrameFormat::Position>(policy));
}

void QTextFrameFormat_SetRightMargin(void* ptr, double margin)
{
	static_cast<QTextFrameFormat*>(ptr)->setRightMargin(margin);
}

void QTextFrameFormat_SetTopMargin(void* ptr, double margin)
{
	static_cast<QTextFrameFormat*>(ptr)->setTopMargin(margin);
}

void QTextFrameFormat_SetWidth(void* ptr, void* width)
{
	static_cast<QTextFrameFormat*>(ptr)->setWidth(*static_cast<QTextLength*>(width));
}

void QTextFrameFormat_SetWidth2(void* ptr, double width)
{
	static_cast<QTextFrameFormat*>(ptr)->setWidth(width);
}

long long QTextFrameFormat_BorderStyle(void* ptr)
{
	return static_cast<QTextFrameFormat*>(ptr)->borderStyle();
}

long long QTextFrameFormat_PageBreakPolicy(void* ptr)
{
	return static_cast<QTextFrameFormat*>(ptr)->pageBreakPolicy();
}

long long QTextFrameFormat_Position(void* ptr)
{
	return static_cast<QTextFrameFormat*>(ptr)->position();
}

void* QTextFrameFormat_BorderBrush(void* ptr)
{
	return new QBrush(static_cast<QTextFrameFormat*>(ptr)->borderBrush());
}

void* QTextFrameFormat_Height(void* ptr)
{
	return new QTextLength(static_cast<QTextFrameFormat*>(ptr)->height());
}

void* QTextFrameFormat_Width(void* ptr)
{
	return new QTextLength(static_cast<QTextFrameFormat*>(ptr)->width());
}

double QTextFrameFormat_Border(void* ptr)
{
	return static_cast<QTextFrameFormat*>(ptr)->border();
}

double QTextFrameFormat_BottomMargin(void* ptr)
{
	return static_cast<QTextFrameFormat*>(ptr)->bottomMargin();
}

double QTextFrameFormat_LeftMargin(void* ptr)
{
	return static_cast<QTextFrameFormat*>(ptr)->leftMargin();
}

double QTextFrameFormat_Margin(void* ptr)
{
	return static_cast<QTextFrameFormat*>(ptr)->margin();
}

double QTextFrameFormat_Padding(void* ptr)
{
	return static_cast<QTextFrameFormat*>(ptr)->padding();
}

double QTextFrameFormat_RightMargin(void* ptr)
{
	return static_cast<QTextFrameFormat*>(ptr)->rightMargin();
}

double QTextFrameFormat_TopMargin(void* ptr)
{
	return static_cast<QTextFrameFormat*>(ptr)->topMargin();
}

void* QTextImageFormat_NewQTextImageFormat()
{
	return new QTextImageFormat();
}

void QTextImageFormat_SetHeight(void* ptr, double height)
{
	static_cast<QTextImageFormat*>(ptr)->setHeight(height);
}

void QTextImageFormat_SetName(void* ptr, char* name)
{
	static_cast<QTextImageFormat*>(ptr)->setName(QString(name));
}

void QTextImageFormat_SetWidth(void* ptr, double width)
{
	static_cast<QTextImageFormat*>(ptr)->setWidth(width);
}

struct QtGui_PackedString QTextImageFormat_Name(void* ptr)
{
	return ({ QByteArray t290038 = static_cast<QTextImageFormat*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(t290038.prepend("WHITESPACE").constData()+10), t290038.size()-10 }; });
}

double QTextImageFormat_Height(void* ptr)
{
	return static_cast<QTextImageFormat*>(ptr)->height();
}

double QTextImageFormat_Width(void* ptr)
{
	return static_cast<QTextImageFormat*>(ptr)->width();
}

void QTextInlineObject_SetAscent(void* ptr, double a)
{
	static_cast<QTextInlineObject*>(ptr)->setAscent(a);
}

void QTextInlineObject_SetDescent(void* ptr, double d)
{
	static_cast<QTextInlineObject*>(ptr)->setDescent(d);
}

void QTextInlineObject_SetWidth(void* ptr, double w)
{
	static_cast<QTextInlineObject*>(ptr)->setWidth(w);
}

void* QTextInlineObject_Rect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QTextInlineObject*>(ptr)->rect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTextInlineObject_Format(void* ptr)
{
	return new QTextFormat(static_cast<QTextInlineObject*>(ptr)->format());
}

long long QTextInlineObject_TextDirection(void* ptr)
{
	return static_cast<QTextInlineObject*>(ptr)->textDirection();
}

char QTextInlineObject_IsValid(void* ptr)
{
	return static_cast<QTextInlineObject*>(ptr)->isValid();
}

int QTextInlineObject_FormatIndex(void* ptr)
{
	return static_cast<QTextInlineObject*>(ptr)->formatIndex();
}

int QTextInlineObject_TextPosition(void* ptr)
{
	return static_cast<QTextInlineObject*>(ptr)->textPosition();
}

double QTextInlineObject_Ascent(void* ptr)
{
	return static_cast<QTextInlineObject*>(ptr)->ascent();
}

double QTextInlineObject_Descent(void* ptr)
{
	return static_cast<QTextInlineObject*>(ptr)->descent();
}

double QTextInlineObject_Height(void* ptr)
{
	return static_cast<QTextInlineObject*>(ptr)->height();
}

double QTextInlineObject_Width(void* ptr)
{
	return static_cast<QTextInlineObject*>(ptr)->width();
}

void* QTextItem_Font(void* ptr)
{
	return new QFont(static_cast<QTextItem*>(ptr)->font());
}

struct QtGui_PackedString QTextItem_Text(void* ptr)
{
	return ({ QByteArray te8cb06 = static_cast<QTextItem*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(te8cb06.prepend("WHITESPACE").constData()+10), te8cb06.size()-10 }; });
}

long long QTextItem_RenderFlags(void* ptr)
{
	return static_cast<QTextItem*>(ptr)->renderFlags();
}

double QTextItem_Ascent(void* ptr)
{
	return static_cast<QTextItem*>(ptr)->ascent();
}

double QTextItem_Descent(void* ptr)
{
	return static_cast<QTextItem*>(ptr)->descent();
}

double QTextItem_Width(void* ptr)
{
	return static_cast<QTextItem*>(ptr)->width();
}

void* QTextLayout_NewQTextLayout()
{
	return new QTextLayout();
}

void* QTextLayout_NewQTextLayout2(char* text)
{
	return new QTextLayout(QString(text));
}

void* QTextLayout_NewQTextLayout3(char* text, void* font, void* paintdevice)
{
	return new QTextLayout(QString(text), *static_cast<QFont*>(font), static_cast<QPaintDevice*>(paintdevice));
}

void* QTextLayout_CreateLine(void* ptr)
{
	return new QTextLine(static_cast<QTextLayout*>(ptr)->createLine());
}

void QTextLayout_BeginLayout(void* ptr)
{
	static_cast<QTextLayout*>(ptr)->beginLayout();
}

void QTextLayout_ClearFormats(void* ptr)
{
	static_cast<QTextLayout*>(ptr)->clearFormats();
}

void QTextLayout_ClearLayout(void* ptr)
{
	static_cast<QTextLayout*>(ptr)->clearLayout();
}

void QTextLayout_EndLayout(void* ptr)
{
	static_cast<QTextLayout*>(ptr)->endLayout();
}

void QTextLayout_SetCacheEnabled(void* ptr, char enable)
{
	static_cast<QTextLayout*>(ptr)->setCacheEnabled(enable != 0);
}

void QTextLayout_SetCursorMoveStyle(void* ptr, long long style)
{
	static_cast<QTextLayout*>(ptr)->setCursorMoveStyle(static_cast<Qt::CursorMoveStyle>(style));
}

void QTextLayout_SetFont(void* ptr, void* font)
{
	static_cast<QTextLayout*>(ptr)->setFont(*static_cast<QFont*>(font));
}

void QTextLayout_SetPosition(void* ptr, void* p)
{
	static_cast<QTextLayout*>(ptr)->setPosition(*static_cast<QPointF*>(p));
}

void QTextLayout_SetPreeditArea(void* ptr, int position, char* text)
{
	static_cast<QTextLayout*>(ptr)->setPreeditArea(position, QString(text));
}

void QTextLayout_SetText(void* ptr, char* stri)
{
	static_cast<QTextLayout*>(ptr)->setText(QString(stri));
}

void QTextLayout_SetTextOption(void* ptr, void* option)
{
	static_cast<QTextLayout*>(ptr)->setTextOption(*static_cast<QTextOption*>(option));
}

void QTextLayout_DestroyQTextLayout(void* ptr)
{
	static_cast<QTextLayout*>(ptr)->~QTextLayout();
}

void* QTextLayout_Font(void* ptr)
{
	return new QFont(static_cast<QTextLayout*>(ptr)->font());
}

struct QtGui_PackedList QTextLayout_GlyphRuns(void* ptr, int from, int length)
{
	return ({ QList<QGlyphRun>* tmpValue = new QList<QGlyphRun>(static_cast<QTextLayout*>(ptr)->glyphRuns(from, length)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QTextLayout_Position(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QTextLayout*>(ptr)->position(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QTextLayout_BoundingRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QTextLayout*>(ptr)->boundingRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

struct QtGui_PackedString QTextLayout_PreeditAreaText(void* ptr)
{
	return ({ QByteArray t04bdaa = static_cast<QTextLayout*>(ptr)->preeditAreaText().toUtf8(); QtGui_PackedString { const_cast<char*>(t04bdaa.prepend("WHITESPACE").constData()+10), t04bdaa.size()-10 }; });
}

struct QtGui_PackedString QTextLayout_Text(void* ptr)
{
	return ({ QByteArray t7e8d3c = static_cast<QTextLayout*>(ptr)->text().toUtf8(); QtGui_PackedString { const_cast<char*>(t7e8d3c.prepend("WHITESPACE").constData()+10), t7e8d3c.size()-10 }; });
}

void* QTextLayout_LineAt(void* ptr, int i)
{
	return new QTextLine(static_cast<QTextLayout*>(ptr)->lineAt(i));
}

void* QTextLayout_LineForTextPosition(void* ptr, int pos)
{
	return new QTextLine(static_cast<QTextLayout*>(ptr)->lineForTextPosition(pos));
}

long long QTextLayout_CursorMoveStyle(void* ptr)
{
	return static_cast<QTextLayout*>(ptr)->cursorMoveStyle();
}

char QTextLayout_CacheEnabled(void* ptr)
{
	return static_cast<QTextLayout*>(ptr)->cacheEnabled();
}

char QTextLayout_IsValidCursorPosition(void* ptr, int pos)
{
	return static_cast<QTextLayout*>(ptr)->isValidCursorPosition(pos);
}

void* QTextLayout_TextOption(void* ptr)
{
	return const_cast<QTextOption*>(&static_cast<QTextLayout*>(ptr)->textOption());
}

int QTextLayout_LeftCursorPosition(void* ptr, int oldPos)
{
	return static_cast<QTextLayout*>(ptr)->leftCursorPosition(oldPos);
}

int QTextLayout_LineCount(void* ptr)
{
	return static_cast<QTextLayout*>(ptr)->lineCount();
}

int QTextLayout_NextCursorPosition(void* ptr, int oldPos, long long mode)
{
	return static_cast<QTextLayout*>(ptr)->nextCursorPosition(oldPos, static_cast<QTextLayout::CursorMode>(mode));
}

int QTextLayout_PreeditAreaPosition(void* ptr)
{
	return static_cast<QTextLayout*>(ptr)->preeditAreaPosition();
}

int QTextLayout_PreviousCursorPosition(void* ptr, int oldPos, long long mode)
{
	return static_cast<QTextLayout*>(ptr)->previousCursorPosition(oldPos, static_cast<QTextLayout::CursorMode>(mode));
}

int QTextLayout_RightCursorPosition(void* ptr, int oldPos)
{
	return static_cast<QTextLayout*>(ptr)->rightCursorPosition(oldPos);
}

double QTextLayout_MaximumWidth(void* ptr)
{
	return static_cast<QTextLayout*>(ptr)->maximumWidth();
}

double QTextLayout_MinimumWidth(void* ptr)
{
	return static_cast<QTextLayout*>(ptr)->minimumWidth();
}

void QTextLayout_DrawCursor2(void* ptr, void* painter, void* position, int cursorPosition)
{
	static_cast<QTextLayout*>(ptr)->drawCursor(static_cast<QPainter*>(painter), *static_cast<QPointF*>(position), cursorPosition);
}

void QTextLayout_DrawCursor(void* ptr, void* painter, void* position, int cursorPosition, int width)
{
	static_cast<QTextLayout*>(ptr)->drawCursor(static_cast<QPainter*>(painter), *static_cast<QPointF*>(position), cursorPosition, width);
}

void* QTextLayout___glyphRuns_atList(void* ptr, int i)
{
	return new QGlyphRun(static_cast<QList<QGlyphRun>*>(ptr)->at(i));
}

void QTextLayout___glyphRuns_setList(void* ptr, void* i)
{
	static_cast<QList<QGlyphRun>*>(ptr)->append(*static_cast<QGlyphRun*>(i));
}

void* QTextLayout___glyphRuns_newList(void* ptr)
{
	return new QList<QGlyphRun>;
}

void* QTextLength_NewQTextLength()
{
	return new QTextLength();
}

void* QTextLength_NewQTextLength2(long long ty, double value)
{
	return new QTextLength(static_cast<QTextLength::Type>(ty), value);
}

long long QTextLength_Type(void* ptr)
{
	return static_cast<QTextLength*>(ptr)->type();
}

double QTextLength_RawValue(void* ptr)
{
	return static_cast<QTextLength*>(ptr)->rawValue();
}

double QTextLength_Value(void* ptr, double maximumLength)
{
	return static_cast<QTextLength*>(ptr)->value(maximumLength);
}

void* QTextLine_NewQTextLine()
{
	return new QTextLine();
}

int QTextLine_XToCursor(void* ptr, double x, long long cpos)
{
	return static_cast<QTextLine*>(ptr)->xToCursor(x, static_cast<QTextLine::CursorPosition>(cpos));
}

void QTextLine_SetLeadingIncluded(void* ptr, char included)
{
	static_cast<QTextLine*>(ptr)->setLeadingIncluded(included != 0);
}

void QTextLine_SetLineWidth(void* ptr, double width)
{
	static_cast<QTextLine*>(ptr)->setLineWidth(width);
}

void QTextLine_SetNumColumns(void* ptr, int numColumns)
{
	static_cast<QTextLine*>(ptr)->setNumColumns(numColumns);
}

void QTextLine_SetNumColumns2(void* ptr, int numColumns, double alignmentWidth)
{
	static_cast<QTextLine*>(ptr)->setNumColumns(numColumns, alignmentWidth);
}

void QTextLine_SetPosition(void* ptr, void* pos)
{
	static_cast<QTextLine*>(ptr)->setPosition(*static_cast<QPointF*>(pos));
}

struct QtGui_PackedList QTextLine_GlyphRuns(void* ptr, int from, int length)
{
	return ({ QList<QGlyphRun>* tmpValue = new QList<QGlyphRun>(static_cast<QTextLine*>(ptr)->glyphRuns(from, length)); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QTextLine_Position(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QTextLine*>(ptr)->position(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QTextLine_NaturalTextRect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QTextLine*>(ptr)->naturalTextRect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTextLine_Rect(void* ptr)
{
	return ({ QRectF tmpValue = static_cast<QTextLine*>(ptr)->rect(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

char QTextLine_IsValid(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->isValid();
}

char QTextLine_LeadingIncluded(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->leadingIncluded();
}

int QTextLine_LineNumber(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->lineNumber();
}

int QTextLine_TextLength(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->textLength();
}

int QTextLine_TextStart(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->textStart();
}

double QTextLine_Ascent(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->ascent();
}

double QTextLine_CursorToX(void* ptr, int cursorPos, long long edge)
{
	return static_cast<QTextLine*>(ptr)->cursorToX(&cursorPos, static_cast<QTextLine::Edge>(edge));
}

double QTextLine_CursorToX2(void* ptr, int cursorPos, long long edge)
{
	return static_cast<QTextLine*>(ptr)->cursorToX(cursorPos, static_cast<QTextLine::Edge>(edge));
}

double QTextLine_Descent(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->descent();
}

double QTextLine_Height(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->height();
}

double QTextLine_HorizontalAdvance(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->horizontalAdvance();
}

double QTextLine_Leading(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->leading();
}

double QTextLine_NaturalTextWidth(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->naturalTextWidth();
}

double QTextLine_Width(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->width();
}

double QTextLine_X(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->x();
}

double QTextLine_Y(void* ptr)
{
	return static_cast<QTextLine*>(ptr)->y();
}

void* QTextLine___glyphRuns_atList(void* ptr, int i)
{
	return new QGlyphRun(static_cast<QList<QGlyphRun>*>(ptr)->at(i));
}

void QTextLine___glyphRuns_setList(void* ptr, void* i)
{
	static_cast<QList<QGlyphRun>*>(ptr)->append(*static_cast<QGlyphRun*>(i));
}

void* QTextLine___glyphRuns_newList(void* ptr)
{
	return new QList<QGlyphRun>;
}

class MyQTextList: public QTextList
{
public:
	void blockFormatChanged(const QTextBlock & block) { callbackQTextBlockGroup_BlockFormatChanged(this, const_cast<QTextBlock*>(&block)); };
	void blockInserted(const QTextBlock & block) { callbackQTextBlockGroup_BlockInserted(this, const_cast<QTextBlock*>(&block)); };
	void blockRemoved(const QTextBlock & block) { callbackQTextBlockGroup_BlockRemoved(this, const_cast<QTextBlock*>(&block)); };
	bool event(QEvent * e) { return callbackQTextObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextObject_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQTextObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTextObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTextObject_CustomEvent(this, event); };
	void deleteLater() { callbackQTextObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQTextObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTextObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQTextObject_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QTextList_Add(void* ptr, void* block)
{
	static_cast<QTextList*>(ptr)->add(*static_cast<QTextBlock*>(block));
}

void QTextList_Remove(void* ptr, void* block)
{
	static_cast<QTextList*>(ptr)->remove(*static_cast<QTextBlock*>(block));
}

void QTextList_RemoveItem(void* ptr, int i)
{
	static_cast<QTextList*>(ptr)->removeItem(i);
}

void QTextList_SetFormat(void* ptr, void* format)
{
	static_cast<QTextList*>(ptr)->setFormat(*static_cast<QTextListFormat*>(format));
}

struct QtGui_PackedString QTextList_ItemText(void* ptr, void* block)
{
	return ({ QByteArray tedd0af = static_cast<QTextList*>(ptr)->itemText(*static_cast<QTextBlock*>(block)).toUtf8(); QtGui_PackedString { const_cast<char*>(tedd0af.prepend("WHITESPACE").constData()+10), tedd0af.size()-10 }; });
}

void* QTextList_Item(void* ptr, int i)
{
	return new QTextBlock(static_cast<QTextList*>(ptr)->item(i));
}

void* QTextList_Format(void* ptr)
{
	return new QTextListFormat(static_cast<QTextList*>(ptr)->format());
}

int QTextList_Count(void* ptr)
{
	return static_cast<QTextList*>(ptr)->count();
}

int QTextList_ItemNumber(void* ptr, void* block)
{
	return static_cast<QTextList*>(ptr)->itemNumber(*static_cast<QTextBlock*>(block));
}

void* QTextListFormat_NewQTextListFormat()
{
	return new QTextListFormat();
}

void QTextListFormat_SetIndent(void* ptr, int indentation)
{
	static_cast<QTextListFormat*>(ptr)->setIndent(indentation);
}

void QTextListFormat_SetNumberPrefix(void* ptr, char* numberPrefix)
{
	static_cast<QTextListFormat*>(ptr)->setNumberPrefix(QString(numberPrefix));
}

void QTextListFormat_SetNumberSuffix(void* ptr, char* numberSuffix)
{
	static_cast<QTextListFormat*>(ptr)->setNumberSuffix(QString(numberSuffix));
}

void QTextListFormat_SetStyle(void* ptr, long long style)
{
	static_cast<QTextListFormat*>(ptr)->setStyle(static_cast<QTextListFormat::Style>(style));
}

struct QtGui_PackedString QTextListFormat_NumberPrefix(void* ptr)
{
	return ({ QByteArray t46a4a3 = static_cast<QTextListFormat*>(ptr)->numberPrefix().toUtf8(); QtGui_PackedString { const_cast<char*>(t46a4a3.prepend("WHITESPACE").constData()+10), t46a4a3.size()-10 }; });
}

struct QtGui_PackedString QTextListFormat_NumberSuffix(void* ptr)
{
	return ({ QByteArray t6ba6a5 = static_cast<QTextListFormat*>(ptr)->numberSuffix().toUtf8(); QtGui_PackedString { const_cast<char*>(t6ba6a5.prepend("WHITESPACE").constData()+10), t6ba6a5.size()-10 }; });
}

long long QTextListFormat_Style(void* ptr)
{
	return static_cast<QTextListFormat*>(ptr)->style();
}

int QTextListFormat_Indent(void* ptr)
{
	return static_cast<QTextListFormat*>(ptr)->indent();
}

class MyQTextObject: public QTextObject
{
public:
	MyQTextObject(QTextDocument *document) : QTextObject(document) {};
	bool event(QEvent * e) { return callbackQTextObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextObject_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQTextObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTextObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTextObject_CustomEvent(this, event); };
	void deleteLater() { callbackQTextObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQTextObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTextObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQTextObject_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QTextObject_NewQTextObject(void* document)
{
	return new MyQTextObject(static_cast<QTextDocument*>(document));
}

void QTextObject_SetFormat(void* ptr, void* format)
{
	static_cast<QTextObject*>(ptr)->setFormat(*static_cast<QTextFormat*>(format));
}

void QTextObject_DestroyQTextObject(void* ptr)
{
	static_cast<QTextObject*>(ptr)->~QTextObject();
}

void* QTextObject_Document(void* ptr)
{
	return static_cast<QTextObject*>(ptr)->document();
}

void* QTextObject_Format(void* ptr)
{
	return new QTextFormat(static_cast<QTextObject*>(ptr)->format());
}

int QTextObject_FormatIndex(void* ptr)
{
	return static_cast<QTextObject*>(ptr)->formatIndex();
}

int QTextObject_ObjectIndex(void* ptr)
{
	return static_cast<QTextObject*>(ptr)->objectIndex();
}

void* QTextObject___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QTextObject___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QTextObject___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QTextObject___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QTextObject___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QTextObject___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QTextObject___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QTextObject___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QTextObject___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QTextObject___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QTextObject___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QTextObject___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QTextObject___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QTextObject___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QTextObject___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QTextObject_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextTable*>(ptr)->QTextTable::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextFrame*>(ptr)->QTextFrame::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextList*>(ptr)->QTextList::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
		return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QTextObject*>(ptr)->QTextObject::event(static_cast<QEvent*>(e));
	}
}

char QTextObject_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextTable*>(ptr)->QTextTable::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextTable*>(ptr)->QTextTable::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextTable*>(ptr)->QTextTable::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextTable*>(ptr)->QTextTable::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTextTable*>(ptr)->QTextTable::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextFrame*>(ptr)->QTextFrame::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextFrame*>(ptr)->QTextFrame::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextFrame*>(ptr)->QTextFrame::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextFrame*>(ptr)->QTextFrame::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTextFrame*>(ptr)->QTextFrame::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextList*>(ptr)->QTextList::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextList*>(ptr)->QTextList::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextList*>(ptr)->QTextList::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextList*>(ptr)->QTextList::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTextList*>(ptr)->QTextList::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextObject*>(ptr)->QTextObject::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextObject*>(ptr)->QTextObject::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextObject*>(ptr)->QTextObject::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QTextObject*>(ptr)->QTextObject::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QTextObject*>(ptr)->QTextObject::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void QTextObject_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextTable*>(ptr)->QTextTable::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextFrame*>(ptr)->QTextFrame::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextList*>(ptr)->QTextList::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QTextObject*>(ptr)->QTextObject::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QTextObject_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextTable*>(ptr)->QTextTable::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextFrame*>(ptr)->QTextFrame::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextList*>(ptr)->QTextList::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QTextObject*>(ptr)->QTextObject::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QTextObject_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextTable*>(ptr)->QTextTable::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextFrame*>(ptr)->QTextFrame::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextList*>(ptr)->QTextList::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QTextObject*>(ptr)->QTextObject::customEvent(static_cast<QEvent*>(event));
	}
}

void QTextObject_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextTable*>(ptr)->QTextTable::deleteLater();
	} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextFrame*>(ptr)->QTextFrame::deleteLater();
	} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextList*>(ptr)->QTextList::deleteLater();
	} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::deleteLater();
	} else {
		static_cast<QTextObject*>(ptr)->QTextObject::deleteLater();
	}
}

void QTextObject_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextTable*>(ptr)->QTextTable::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextFrame*>(ptr)->QTextFrame::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextList*>(ptr)->QTextList::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QTextObject*>(ptr)->QTextObject::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QTextObject_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextTable*>(ptr)->QTextTable::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextFrame*>(ptr)->QTextFrame::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextList*>(ptr)->QTextList::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
		static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QTextObject*>(ptr)->QTextObject::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

void* QTextObject_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QTextTable*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTextTable*>(ptr)->QTextTable::metaObject());
	} else if (dynamic_cast<QTextFrame*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTextFrame*>(ptr)->QTextFrame::metaObject());
	} else if (dynamic_cast<QTextList*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTextList*>(ptr)->QTextList::metaObject());
	} else if (dynamic_cast<QTextBlockGroup*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QTextBlockGroup*>(ptr)->QTextBlockGroup::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QTextObject*>(ptr)->QTextObject::metaObject());
	}
}

class MyQTextObjectInterface: public QTextObjectInterface
{
public:
	QSizeF intrinsicSize(QTextDocument * doc, int posInDocument, const QTextFormat & format) { return *static_cast<QSizeF*>(callbackQTextObjectInterface_IntrinsicSize(this, doc, posInDocument, const_cast<QTextFormat*>(&format))); };
	void drawObject(QPainter * painter, const QRectF & rect, QTextDocument * doc, int posInDocument, const QTextFormat & format) { callbackQTextObjectInterface_DrawObject(this, painter, const_cast<QRectF*>(&rect), doc, posInDocument, const_cast<QTextFormat*>(&format)); };
	 ~MyQTextObjectInterface() { callbackQTextObjectInterface_DestroyQTextObjectInterface(this); };
};

void* QTextObjectInterface_IntrinsicSize(void* ptr, void* doc, int posInDocument, void* format)
{
	return ({ QSizeF tmpValue = static_cast<QTextObjectInterface*>(ptr)->intrinsicSize(static_cast<QTextDocument*>(doc), posInDocument, *static_cast<QTextFormat*>(format)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}

void QTextObjectInterface_DrawObject(void* ptr, void* painter, void* rect, void* doc, int posInDocument, void* format)
{
	static_cast<QTextObjectInterface*>(ptr)->drawObject(static_cast<QPainter*>(painter), *static_cast<QRectF*>(rect), static_cast<QTextDocument*>(doc), posInDocument, *static_cast<QTextFormat*>(format));
}

void QTextObjectInterface_DestroyQTextObjectInterface(void* ptr)
{
	static_cast<QTextObjectInterface*>(ptr)->~QTextObjectInterface();
}

void QTextObjectInterface_DestroyQTextObjectInterfaceDefault(void* ptr)
{

}

void* QTextOption_NewQTextOption3(void* other)
{
	return new QTextOption(*static_cast<QTextOption*>(other));
}

void* QTextOption_NewQTextOption()
{
	return new QTextOption();
}

void* QTextOption_NewQTextOption2(long long alignment)
{
	return new QTextOption(static_cast<Qt::AlignmentFlag>(alignment));
}

void QTextOption_SetAlignment(void* ptr, long long alignment)
{
	static_cast<QTextOption*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QTextOption_SetFlags(void* ptr, long long flags)
{
	static_cast<QTextOption*>(ptr)->setFlags(static_cast<QTextOption::Flag>(flags));
}

void QTextOption_SetTabArray(void* ptr, void* tabStops)
{
	static_cast<QTextOption*>(ptr)->setTabArray(*static_cast<QList<qreal>*>(tabStops));
}

void QTextOption_SetTabStop(void* ptr, double tabStop)
{
	static_cast<QTextOption*>(ptr)->setTabStop(tabStop);
}

void QTextOption_SetTextDirection(void* ptr, long long direction)
{
	static_cast<QTextOption*>(ptr)->setTextDirection(static_cast<Qt::LayoutDirection>(direction));
}

void QTextOption_SetUseDesignMetrics(void* ptr, char enable)
{
	static_cast<QTextOption*>(ptr)->setUseDesignMetrics(enable != 0);
}

void QTextOption_SetWrapMode(void* ptr, long long mode)
{
	static_cast<QTextOption*>(ptr)->setWrapMode(static_cast<QTextOption::WrapMode>(mode));
}

void QTextOption_DestroyQTextOption(void* ptr)
{
	static_cast<QTextOption*>(ptr)->~QTextOption();
}

long long QTextOption_Flags(void* ptr)
{
	return static_cast<QTextOption*>(ptr)->flags();
}

struct QtGui_PackedList QTextOption_TabArray(void* ptr)
{
	return ({ QList<qreal>* tmpValue = new QList<qreal>(static_cast<QTextOption*>(ptr)->tabArray()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

long long QTextOption_Alignment(void* ptr)
{
	return static_cast<QTextOption*>(ptr)->alignment();
}

long long QTextOption_TextDirection(void* ptr)
{
	return static_cast<QTextOption*>(ptr)->textDirection();
}

long long QTextOption_WrapMode(void* ptr)
{
	return static_cast<QTextOption*>(ptr)->wrapMode();
}

char QTextOption_UseDesignMetrics(void* ptr)
{
	return static_cast<QTextOption*>(ptr)->useDesignMetrics();
}

double QTextOption_TabStop(void* ptr)
{
	return static_cast<QTextOption*>(ptr)->tabStop();
}

double QTextOption___setTabArray_tabStops_atList(void* ptr, int i)
{
	return static_cast<QList<qreal>*>(ptr)->at(i);
}

void QTextOption___setTabArray_tabStops_setList(void* ptr, double i)
{
	static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QTextOption___setTabArray_tabStops_newList(void* ptr)
{
	return new QList<qreal>;
}

double QTextOption___tabArray_atList(void* ptr, int i)
{
	return static_cast<QList<qreal>*>(ptr)->at(i);
}

void QTextOption___tabArray_setList(void* ptr, double i)
{
	static_cast<QList<qreal>*>(ptr)->append(i);
}

void* QTextOption___tabArray_newList(void* ptr)
{
	return new QList<qreal>;
}

class MyQTextTable: public QTextTable
{
public:
	bool event(QEvent * e) { return callbackQTextObject_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQTextObject_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQTextObject_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQTextObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQTextObject_CustomEvent(this, event); };
	void deleteLater() { callbackQTextObject_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQTextObject_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQTextObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQTextObject_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQTextObject_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQTextObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QTextTable_AppendColumns(void* ptr, int count)
{
	static_cast<QTextTable*>(ptr)->appendColumns(count);
}

void QTextTable_AppendRows(void* ptr, int count)
{
	static_cast<QTextTable*>(ptr)->appendRows(count);
}

void QTextTable_InsertColumns(void* ptr, int index, int columns)
{
	static_cast<QTextTable*>(ptr)->insertColumns(index, columns);
}

void QTextTable_InsertRows(void* ptr, int index, int rows)
{
	static_cast<QTextTable*>(ptr)->insertRows(index, rows);
}

void QTextTable_MergeCells2(void* ptr, void* cursor)
{
	static_cast<QTextTable*>(ptr)->mergeCells(*static_cast<QTextCursor*>(cursor));
}

void QTextTable_MergeCells(void* ptr, int row, int column, int numRows, int numCols)
{
	static_cast<QTextTable*>(ptr)->mergeCells(row, column, numRows, numCols);
}

void QTextTable_RemoveColumns(void* ptr, int index, int columns)
{
	static_cast<QTextTable*>(ptr)->removeColumns(index, columns);
}

void QTextTable_RemoveRows(void* ptr, int index, int rows)
{
	static_cast<QTextTable*>(ptr)->removeRows(index, rows);
}

void QTextTable_Resize(void* ptr, int rows, int columns)
{
	static_cast<QTextTable*>(ptr)->resize(rows, columns);
}

void QTextTable_SetFormat(void* ptr, void* format)
{
	static_cast<QTextTable*>(ptr)->setFormat(*static_cast<QTextTableFormat*>(format));
}

void QTextTable_SplitCell(void* ptr, int row, int column, int numRows, int numCols)
{
	static_cast<QTextTable*>(ptr)->splitCell(row, column, numRows, numCols);
}

void* QTextTable_RowEnd(void* ptr, void* cursor)
{
	return new QTextCursor(static_cast<QTextTable*>(ptr)->rowEnd(*static_cast<QTextCursor*>(cursor)));
}

void* QTextTable_RowStart(void* ptr, void* cursor)
{
	return new QTextCursor(static_cast<QTextTable*>(ptr)->rowStart(*static_cast<QTextCursor*>(cursor)));
}

void* QTextTable_CellAt3(void* ptr, void* cursor)
{
	return new QTextTableCell(static_cast<QTextTable*>(ptr)->cellAt(*static_cast<QTextCursor*>(cursor)));
}

void* QTextTable_CellAt2(void* ptr, int position)
{
	return new QTextTableCell(static_cast<QTextTable*>(ptr)->cellAt(position));
}

void* QTextTable_CellAt(void* ptr, int row, int column)
{
	return new QTextTableCell(static_cast<QTextTable*>(ptr)->cellAt(row, column));
}

void* QTextTable_Format(void* ptr)
{
	return new QTextTableFormat(static_cast<QTextTable*>(ptr)->format());
}

int QTextTable_Columns(void* ptr)
{
	return static_cast<QTextTable*>(ptr)->columns();
}

int QTextTable_Rows(void* ptr)
{
	return static_cast<QTextTable*>(ptr)->rows();
}

void* QTextTableCell_NewQTextTableCell()
{
	return new QTextTableCell();
}

void* QTextTableCell_NewQTextTableCell2(void* other)
{
	return new QTextTableCell(*static_cast<QTextTableCell*>(other));
}

void QTextTableCell_SetFormat(void* ptr, void* format)
{
	static_cast<QTextTableCell*>(ptr)->setFormat(*static_cast<QTextCharFormat*>(format));
}

void QTextTableCell_DestroyQTextTableCell(void* ptr)
{
	static_cast<QTextTableCell*>(ptr)->~QTextTableCell();
}

void* QTextTableCell_Format(void* ptr)
{
	return new QTextCharFormat(static_cast<QTextTableCell*>(ptr)->format());
}

void* QTextTableCell_FirstCursorPosition(void* ptr)
{
	return new QTextCursor(static_cast<QTextTableCell*>(ptr)->firstCursorPosition());
}

void* QTextTableCell_LastCursorPosition(void* ptr)
{
	return new QTextCursor(static_cast<QTextTableCell*>(ptr)->lastCursorPosition());
}

char QTextTableCell_IsValid(void* ptr)
{
	return static_cast<QTextTableCell*>(ptr)->isValid();
}

int QTextTableCell_Column(void* ptr)
{
	return static_cast<QTextTableCell*>(ptr)->column();
}

int QTextTableCell_ColumnSpan(void* ptr)
{
	return static_cast<QTextTableCell*>(ptr)->columnSpan();
}

int QTextTableCell_Row(void* ptr)
{
	return static_cast<QTextTableCell*>(ptr)->row();
}

int QTextTableCell_RowSpan(void* ptr)
{
	return static_cast<QTextTableCell*>(ptr)->rowSpan();
}

int QTextTableCell_TableCellFormatIndex(void* ptr)
{
	return static_cast<QTextTableCell*>(ptr)->tableCellFormatIndex();
}

void* QTextTableCellFormat_NewQTextTableCellFormat()
{
	return new QTextTableCellFormat();
}

void QTextTableCellFormat_SetBottomPadding(void* ptr, double padding)
{
	static_cast<QTextTableCellFormat*>(ptr)->setBottomPadding(padding);
}

void QTextTableCellFormat_SetLeftPadding(void* ptr, double padding)
{
	static_cast<QTextTableCellFormat*>(ptr)->setLeftPadding(padding);
}

void QTextTableCellFormat_SetPadding(void* ptr, double padding)
{
	static_cast<QTextTableCellFormat*>(ptr)->setPadding(padding);
}

void QTextTableCellFormat_SetRightPadding(void* ptr, double padding)
{
	static_cast<QTextTableCellFormat*>(ptr)->setRightPadding(padding);
}

void QTextTableCellFormat_SetTopPadding(void* ptr, double padding)
{
	static_cast<QTextTableCellFormat*>(ptr)->setTopPadding(padding);
}

double QTextTableCellFormat_BottomPadding(void* ptr)
{
	return static_cast<QTextTableCellFormat*>(ptr)->bottomPadding();
}

double QTextTableCellFormat_LeftPadding(void* ptr)
{
	return static_cast<QTextTableCellFormat*>(ptr)->leftPadding();
}

double QTextTableCellFormat_RightPadding(void* ptr)
{
	return static_cast<QTextTableCellFormat*>(ptr)->rightPadding();
}

double QTextTableCellFormat_TopPadding(void* ptr)
{
	return static_cast<QTextTableCellFormat*>(ptr)->topPadding();
}

void* QTextTableFormat_NewQTextTableFormat()
{
	return new QTextTableFormat();
}

void QTextTableFormat_ClearColumnWidthConstraints(void* ptr)
{
	static_cast<QTextTableFormat*>(ptr)->clearColumnWidthConstraints();
}

void QTextTableFormat_SetAlignment(void* ptr, long long alignment)
{
	static_cast<QTextTableFormat*>(ptr)->setAlignment(static_cast<Qt::AlignmentFlag>(alignment));
}

void QTextTableFormat_SetCellPadding(void* ptr, double padding)
{
	static_cast<QTextTableFormat*>(ptr)->setCellPadding(padding);
}

void QTextTableFormat_SetCellSpacing(void* ptr, double spacing)
{
	static_cast<QTextTableFormat*>(ptr)->setCellSpacing(spacing);
}

void QTextTableFormat_SetColumnWidthConstraints(void* ptr, void* constraints)
{
	static_cast<QTextTableFormat*>(ptr)->setColumnWidthConstraints(*static_cast<QVector<QTextLength>*>(constraints));
}

void QTextTableFormat_SetHeaderRowCount(void* ptr, int count)
{
	static_cast<QTextTableFormat*>(ptr)->setHeaderRowCount(count);
}

long long QTextTableFormat_Alignment(void* ptr)
{
	return static_cast<QTextTableFormat*>(ptr)->alignment();
}

int QTextTableFormat_Columns(void* ptr)
{
	return static_cast<QTextTableFormat*>(ptr)->columns();
}

int QTextTableFormat_HeaderRowCount(void* ptr)
{
	return static_cast<QTextTableFormat*>(ptr)->headerRowCount();
}

double QTextTableFormat_CellPadding(void* ptr)
{
	return static_cast<QTextTableFormat*>(ptr)->cellPadding();
}

double QTextTableFormat_CellSpacing(void* ptr)
{
	return static_cast<QTextTableFormat*>(ptr)->cellSpacing();
}

void* QTextTableFormat___setColumnWidthConstraints_constraints_atList(void* ptr, int i)
{
	return new QTextLength(static_cast<QVector<QTextLength>*>(ptr)->at(i));
}

void QTextTableFormat___setColumnWidthConstraints_constraints_setList(void* ptr, void* i)
{
	static_cast<QVector<QTextLength>*>(ptr)->append(*static_cast<QTextLength*>(i));
}

void* QTextTableFormat___setColumnWidthConstraints_constraints_newList(void* ptr)
{
	return new QVector<QTextLength>;
}

void* QTextTableFormat___columnWidthConstraints_atList(void* ptr, int i)
{
	return new QTextLength(static_cast<QVector<QTextLength>*>(ptr)->at(i));
}

void QTextTableFormat___columnWidthConstraints_setList(void* ptr, void* i)
{
	static_cast<QVector<QTextLength>*>(ptr)->append(*static_cast<QTextLength*>(i));
}

void* QTextTableFormat___columnWidthConstraints_newList(void* ptr)
{
	return new QVector<QTextLength>;
}

struct QtGui_PackedList QTouchDevice_QTouchDevice_Devices()
{
	return ({ QList<const QTouchDevice *>* tmpValue = new QList<const QTouchDevice *>(QTouchDevice::devices()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}

void* QTouchDevice_NewQTouchDevice()
{
	return new QTouchDevice();
}

void QTouchDevice_SetCapabilities(void* ptr, long long caps)
{
	static_cast<QTouchDevice*>(ptr)->setCapabilities(static_cast<QTouchDevice::CapabilityFlag>(caps));
}

void QTouchDevice_SetMaximumTouchPoints(void* ptr, int max)
{
	static_cast<QTouchDevice*>(ptr)->setMaximumTouchPoints(max);
}

void QTouchDevice_SetName(void* ptr, char* name)
{
	static_cast<QTouchDevice*>(ptr)->setName(QString(name));
}

void QTouchDevice_SetType(void* ptr, long long devType)
{
	static_cast<QTouchDevice*>(ptr)->setType(static_cast<QTouchDevice::DeviceType>(devType));
}

void QTouchDevice_DestroyQTouchDevice(void* ptr)
{
	static_cast<QTouchDevice*>(ptr)->~QTouchDevice();
}

long long QTouchDevice_Capabilities(void* ptr)
{
	return static_cast<QTouchDevice*>(ptr)->capabilities();
}

long long QTouchDevice_Type(void* ptr)
{
	return static_cast<QTouchDevice*>(ptr)->type();
}

struct QtGui_PackedString QTouchDevice_Name(void* ptr)
{
	return ({ QByteArray td71303 = static_cast<QTouchDevice*>(ptr)->name().toUtf8(); QtGui_PackedString { const_cast<char*>(td71303.prepend("WHITESPACE").constData()+10), td71303.size()-10 }; });
}

int QTouchDevice_MaximumTouchPoints(void* ptr)
{
	return static_cast<QTouchDevice*>(ptr)->maximumTouchPoints();
}

void* QTouchDevice___devices_atList(void* ptr, int i)
{
	return const_cast<QTouchDevice*>(static_cast<QList<const QTouchDevice *>*>(ptr)->at(i));
}

void QTouchDevice___devices_setList(void* ptr, void* i)
{
	static_cast<QList<const QTouchDevice *>*>(ptr)->append(static_cast<QTouchDevice*>(i));
}

void* QTouchDevice___devices_newList(void* ptr)
{
	return new QList<const QTouchDevice *>;
}

class MyQTouchEvent: public QTouchEvent
{
public:
};

void QTouchEvent_DestroyQTouchEvent(void* ptr)
{
	static_cast<QTouchEvent*>(ptr)->~QTouchEvent();
}

void* QTouchEvent_Target(void* ptr)
{
	return static_cast<QTouchEvent*>(ptr)->target();
}

void* QTouchEvent_Device(void* ptr)
{
	return static_cast<QTouchEvent*>(ptr)->device();
}

void* QTouchEvent_Window(void* ptr)
{
	return static_cast<QTouchEvent*>(ptr)->window();
}

long long QTouchEvent_TouchPointStates(void* ptr)
{
	return static_cast<QTouchEvent*>(ptr)->touchPointStates();
}

void* QTouchEvent__device(void* ptr)
{
	return static_cast<QTouchEvent*>(ptr)->_device;
}

void QTouchEvent_Set_device(void* ptr, void* vqt)
{
	static_cast<QTouchEvent*>(ptr)->_device = static_cast<QTouchDevice*>(vqt);
}

void* QTouchEvent__target(void* ptr)
{
	return static_cast<QTouchEvent*>(ptr)->_target;
}

void QTouchEvent_Set_target(void* ptr, void* vqo)
{
		static_cast<QTouchEvent*>(ptr)->_target = static_cast<QObject*>(vqo);
}

long long QTouchEvent__touchPointStates(void* ptr)
{
	return static_cast<QTouchEvent*>(ptr)->_touchPointStates;
}

void QTouchEvent_Set_touchPointStates(void* ptr, long long vqt)
{
	static_cast<QTouchEvent*>(ptr)->_touchPointStates = static_cast<Qt::TouchPointState>(vqt);
}

void* QTouchEvent__window(void* ptr)
{
	return static_cast<QTouchEvent*>(ptr)->_window;
}

void QTouchEvent_Set_window(void* ptr, void* vqw)
{
		static_cast<QTouchEvent*>(ptr)->_window = static_cast<QWindow*>(vqw);
}

void* QTouchEvent___QTouchEvent_touchPoints_newList(void* ptr)
{
	return new QList<QTouchEvent::TouchPoint>;
}

void* QTouchEvent___setTouchPoints_touchPoints_newList(void* ptr)
{
	return new QList<QTouchEvent::TouchPoint>;
}

void* QTouchEvent___touchPoints_newList(void* ptr)
{
	return new QList<QTouchEvent::TouchPoint>;
}

void* QTouchEvent____touchPoints_newList(void* ptr)
{
	return new QList<QTouchEvent::TouchPoint>;
}

void* QTouchEvent___set_touchPoints__newList(void* ptr)
{
	return new QList<QTouchEvent::TouchPoint>;
}

void* QTransform_Rotate(void* ptr, double angle, long long axis)
{
	return new QTransform(static_cast<QTransform*>(ptr)->rotate(angle, static_cast<Qt::Axis>(axis)));
}

void* QTransform_RotateRadians(void* ptr, double angle, long long axis)
{
	return new QTransform(static_cast<QTransform*>(ptr)->rotateRadians(angle, static_cast<Qt::Axis>(axis)));
}

void* QTransform_Scale(void* ptr, double sx, double sy)
{
	return new QTransform(static_cast<QTransform*>(ptr)->scale(sx, sy));
}

void* QTransform_Shear(void* ptr, double sh, double sv)
{
	return new QTransform(static_cast<QTransform*>(ptr)->shear(sh, sv));
}

void* QTransform_Translate(void* ptr, double dx, double dy)
{
	return new QTransform(static_cast<QTransform*>(ptr)->translate(dx, dy));
}

void* QTransform_QTransform_FromScale(double sx, double sy)
{
	return new QTransform(QTransform::fromScale(sx, sy));
}

void* QTransform_QTransform_FromTranslate(double dx, double dy)
{
	return new QTransform(QTransform::fromTranslate(dx, dy));
}

void* QTransform_NewQTransform()
{
	return new QTransform();
}

void* QTransform_NewQTransform6(void* other)
{
	return new QTransform(*static_cast<QTransform*>(other));
}

void* QTransform_NewQTransform7(void* other)
{
	return new QTransform(*static_cast<QTransform*>(other));
}

void* QTransform_NewQTransform3(double m11, double m12, double m13, double m21, double m22, double m23, double m31, double m32, double m33)
{
	return new QTransform(m11, m12, m13, m21, m22, m23, m31, m32, m33);
}

void* QTransform_NewQTransform4(double m11, double m12, double m21, double m22, double dx, double dy)
{
	return new QTransform(m11, m12, m21, m22, dx, dy);
}

char QTransform_QTransform_QuadToQuad(void* one, void* two, void* trans)
{
	return QTransform::quadToQuad(*static_cast<QPolygonF*>(one), *static_cast<QPolygonF*>(two), *static_cast<QTransform*>(trans));
}

char QTransform_QTransform_QuadToSquare(void* quad, void* trans)
{
	return QTransform::quadToSquare(*static_cast<QPolygonF*>(quad), *static_cast<QTransform*>(trans));
}

char QTransform_QTransform_SquareToQuad(void* quad, void* trans)
{
	return QTransform::squareToQuad(*static_cast<QPolygonF*>(quad), *static_cast<QTransform*>(trans));
}

void QTransform_Reset(void* ptr)
{
	static_cast<QTransform*>(ptr)->reset();
}

void QTransform_SetMatrix(void* ptr, double m11, double m12, double m13, double m21, double m22, double m23, double m31, double m32, double m33)
{
	static_cast<QTransform*>(ptr)->setMatrix(m11, m12, m13, m21, m22, m23, m31, m32, m33);
}

void* QTransform_Map3(void* ptr, void* l)
{
	return ({ QLine tmpValue = static_cast<QTransform*>(ptr)->map(*static_cast<QLine*>(l)); new QLine(tmpValue.p1(), tmpValue.p2()); });
}

void* QTransform_Map4(void* ptr, void* line)
{
	return ({ QLineF tmpValue = static_cast<QTransform*>(ptr)->map(*static_cast<QLineF*>(line)); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}

void* QTransform_Map8(void* ptr, void* path)
{
	return new QPainterPath(static_cast<QTransform*>(ptr)->map(*static_cast<QPainterPath*>(path)));
}

void* QTransform_Map10(void* ptr, void* point)
{
	return ({ QPoint tmpValue = static_cast<QTransform*>(ptr)->map(*static_cast<QPoint*>(point)); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QTransform_Map2(void* ptr, void* p)
{
	return ({ QPointF tmpValue = static_cast<QTransform*>(ptr)->map(*static_cast<QPointF*>(p)); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QTransform_Map6(void* ptr, void* polygon)
{
	return new QPolygon(static_cast<QTransform*>(ptr)->map(*static_cast<QPolygon*>(polygon)));
}

void* QTransform_MapToPolygon(void* ptr, void* rectangle)
{
	return new QPolygon(static_cast<QTransform*>(ptr)->mapToPolygon(*static_cast<QRect*>(rectangle)));
}

void* QTransform_Map5(void* ptr, void* polygon)
{
	return new QPolygonF(static_cast<QTransform*>(ptr)->map(*static_cast<QPolygonF*>(polygon)));
}

void* QTransform_MapRect2(void* ptr, void* rectangle)
{
	return ({ QRect tmpValue = static_cast<QTransform*>(ptr)->mapRect(*static_cast<QRect*>(rectangle)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTransform_MapRect(void* ptr, void* rectangle)
{
	return ({ QRectF tmpValue = static_cast<QTransform*>(ptr)->mapRect(*static_cast<QRectF*>(rectangle)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}

void* QTransform_Map7(void* ptr, void* region)
{
	return new QRegion(static_cast<QTransform*>(ptr)->map(*static_cast<QRegion*>(region)));
}

void* QTransform_Adjoint(void* ptr)
{
	return new QTransform(static_cast<QTransform*>(ptr)->adjoint());
}

void* QTransform_Inverted(void* ptr, char invertible)
{
	return new QTransform(static_cast<QTransform*>(ptr)->inverted(NULL));
}

void* QTransform_Transposed(void* ptr)
{
	return new QTransform(static_cast<QTransform*>(ptr)->transposed());
}

long long QTransform_Type(void* ptr)
{
	return static_cast<QTransform*>(ptr)->type();
}

char QTransform_IsAffine(void* ptr)
{
	return static_cast<QTransform*>(ptr)->isAffine();
}

char QTransform_IsIdentity(void* ptr)
{
	return static_cast<QTransform*>(ptr)->isIdentity();
}

char QTransform_IsInvertible(void* ptr)
{
	return static_cast<QTransform*>(ptr)->isInvertible();
}

char QTransform_IsRotating(void* ptr)
{
	return static_cast<QTransform*>(ptr)->isRotating();
}

char QTransform_IsScaling(void* ptr)
{
	return static_cast<QTransform*>(ptr)->isScaling();
}

char QTransform_IsTranslating(void* ptr)
{
	return static_cast<QTransform*>(ptr)->isTranslating();
}

double QTransform_Determinant(void* ptr)
{
	return static_cast<QTransform*>(ptr)->determinant();
}

double QTransform_Dx(void* ptr)
{
	return static_cast<QTransform*>(ptr)->dx();
}

double QTransform_Dy(void* ptr)
{
	return static_cast<QTransform*>(ptr)->dy();
}

double QTransform_M11(void* ptr)
{
	return static_cast<QTransform*>(ptr)->m11();
}

double QTransform_M12(void* ptr)
{
	return static_cast<QTransform*>(ptr)->m12();
}

double QTransform_M13(void* ptr)
{
	return static_cast<QTransform*>(ptr)->m13();
}

double QTransform_M21(void* ptr)
{
	return static_cast<QTransform*>(ptr)->m21();
}

double QTransform_M22(void* ptr)
{
	return static_cast<QTransform*>(ptr)->m22();
}

double QTransform_M23(void* ptr)
{
	return static_cast<QTransform*>(ptr)->m23();
}

double QTransform_M31(void* ptr)
{
	return static_cast<QTransform*>(ptr)->m31();
}

double QTransform_M32(void* ptr)
{
	return static_cast<QTransform*>(ptr)->m32();
}

double QTransform_M33(void* ptr)
{
	return static_cast<QTransform*>(ptr)->m33();
}

void QTransform_Map9(void* ptr, int x, int y, int tx, int ty)
{
	static_cast<QTransform*>(ptr)->map(x, y, &tx, &ty);
}

void QTransform_Map(void* ptr, double x, double y, double tx, double ty)
{
	static_cast<QTransform*>(ptr)->map(x, y, &tx, &ty);
}

class MyQValidator: public QValidator
{
public:
	MyQValidator(QObject *parent) : QValidator(parent) {};
	void Signal_Changed() { callbackQValidator_Changed(this); };
	void fixup(QString & input) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };callbackQValidator_Fixup(const_cast<void*>(static_cast<const void*>(this)), inputPacked); };
	State validate(QString & input, int & pos) const { QByteArray t140f86 = input.toUtf8(); QtGui_PackedString inputPacked = { const_cast<char*>(t140f86.prepend("WHITESPACE").constData()+10), t140f86.size()-10 };return static_cast<QValidator::State>(callbackQValidator_Validate(const_cast<void*>(static_cast<const void*>(this)), inputPacked, pos)); };
	bool event(QEvent * e) { return callbackQValidator_Event(this, e) != 0; };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQValidator_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQValidator_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQValidator_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQValidator_CustomEvent(this, event); };
	void deleteLater() { callbackQValidator_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQValidator_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQValidator_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQValidator_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQValidator_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQValidator_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void QValidator_ConnectChanged(void* ptr)
{
	QObject::connect(static_cast<QValidator*>(ptr), static_cast<void (QValidator::*)()>(&QValidator::changed), static_cast<MyQValidator*>(ptr), static_cast<void (MyQValidator::*)()>(&MyQValidator::Signal_Changed));
}

void QValidator_DisconnectChanged(void* ptr)
{
	QObject::disconnect(static_cast<QValidator*>(ptr), static_cast<void (QValidator::*)()>(&QValidator::changed), static_cast<MyQValidator*>(ptr), static_cast<void (MyQValidator::*)()>(&MyQValidator::Signal_Changed));
}

void QValidator_Changed(void* ptr)
{
	static_cast<QValidator*>(ptr)->changed();
}

void QValidator_Fixup(void* ptr, char* input)
{
	static_cast<QValidator*>(ptr)->fixup(*(new QString(input)));
}

void QValidator_FixupDefault(void* ptr, char* input)
{
	if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::fixup(*(new QString(input)));
	} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::fixup(*(new QString(input)));
	} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QIntValidator*>(ptr)->QIntValidator::fixup(*(new QString(input)));
	} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::fixup(*(new QString(input)));
	} else {
		static_cast<QValidator*>(ptr)->QValidator::fixup(*(new QString(input)));
	}
}

void* QValidator_NewQValidator(void* parent)
{
	return new MyQValidator(static_cast<QObject*>(parent));
}

void QValidator_SetLocale(void* ptr, void* locale)
{
	static_cast<QValidator*>(ptr)->setLocale(*static_cast<QLocale*>(locale));
}

void QValidator_DestroyQValidator(void* ptr)
{
	static_cast<QValidator*>(ptr)->~QValidator();
}

void* QValidator_Locale(void* ptr)
{
	return new QLocale(static_cast<QValidator*>(ptr)->locale());
}

long long QValidator_Validate(void* ptr, char* input, int pos)
{
	return static_cast<QValidator*>(ptr)->validate(*(new QString(input)), pos);
}

void* QValidator___dynamicPropertyNames_atList(void* ptr, int i)
{
	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
}

void QValidator___dynamicPropertyNames_setList(void* ptr, void* i)
{
	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}

void* QValidator___dynamicPropertyNames_newList(void* ptr)
{
	return new QList<QByteArray>;
}

void* QValidator___findChildren_atList2(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QValidator___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QValidator___findChildren_newList2(void* ptr)
{
	return new QList<QObject*>;
}

void* QValidator___findChildren_atList3(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QValidator___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QValidator___findChildren_newList3(void* ptr)
{
	return new QList<QObject*>;
}

void* QValidator___findChildren_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
}

void QValidator___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QValidator___findChildren_newList(void* ptr)
{
	return new QList<QObject*>;
}

void* QValidator___children_atList(void* ptr, int i)
{
	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
}

void QValidator___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
	} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
	} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
	} else {
		static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
	}
}

void* QValidator___children_newList(void* ptr)
{
	return new QList<QObject *>;
}

char QValidator_EventDefault(void* ptr, void* e)
{
	if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
		return static_cast<QIntValidator*>(ptr)->QIntValidator::event(static_cast<QEvent*>(e));
	} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
		return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::event(static_cast<QEvent*>(e));
	} else {
		return static_cast<QValidator*>(ptr)->QValidator::event(static_cast<QEvent*>(e));
	}
}

char QValidator_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QIntValidator*>(ptr)->QIntValidator::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QIntValidator*>(ptr)->QIntValidator::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QIntValidator*>(ptr)->QIntValidator::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QIntValidator*>(ptr)->QIntValidator::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QIntValidator*>(ptr)->QIntValidator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QValidator*>(ptr)->QValidator::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QValidator*>(ptr)->QValidator::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QValidator*>(ptr)->QValidator::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QValidator*>(ptr)->QValidator::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QValidator*>(ptr)->QValidator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void QValidator_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QIntValidator*>(ptr)->QIntValidator::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QValidator*>(ptr)->QValidator::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QValidator_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QIntValidator*>(ptr)->QIntValidator::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QValidator*>(ptr)->QValidator::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QValidator_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QIntValidator*>(ptr)->QIntValidator::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QValidator*>(ptr)->QValidator::customEvent(static_cast<QEvent*>(event));
	}
}

void QValidator_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::deleteLater();
	} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::deleteLater();
	} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QIntValidator*>(ptr)->QIntValidator::deleteLater();
	} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::deleteLater();
	} else {
		static_cast<QValidator*>(ptr)->QValidator::deleteLater();
	}
}

void QValidator_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QIntValidator*>(ptr)->QIntValidator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QValidator*>(ptr)->QValidator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QValidator_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QIntValidator*>(ptr)->QIntValidator::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
		static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QValidator*>(ptr)->QValidator::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

void* QValidator_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QRegularExpressionValidator*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QRegularExpressionValidator*>(ptr)->QRegularExpressionValidator::metaObject());
	} else if (dynamic_cast<QRegExpValidator*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QRegExpValidator*>(ptr)->QRegExpValidator::metaObject());
	} else if (dynamic_cast<QIntValidator*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QIntValidator*>(ptr)->QIntValidator::metaObject());
	} else if (dynamic_cast<QDoubleValidator*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QDoubleValidator*>(ptr)->QDoubleValidator::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QValidator*>(ptr)->QValidator::metaObject());
	}
}

void* QVector2D_NewQVector2D()
{
	return new QVector2D();
}

void* QVector2D_NewQVector2D4(void* point)
{
	return new QVector2D(*static_cast<QPoint*>(point));
}

void* QVector2D_NewQVector2D5(void* point)
{
	return new QVector2D(*static_cast<QPointF*>(point));
}

void* QVector2D_NewQVector2D6(void* vector)
{
	return new QVector2D(*static_cast<QVector3D*>(vector));
}

void* QVector2D_NewQVector2D7(void* vector)
{
	return new QVector2D(*static_cast<QVector4D*>(vector));
}

void* QVector2D_NewQVector2D3(float xpos, float ypos)
{
	return new QVector2D(xpos, ypos);
}

float QVector2D_QVector2D_DotProduct(void* v1, void* v2)
{
	return QVector2D::dotProduct(*static_cast<QVector2D*>(v1), *static_cast<QVector2D*>(v2));
}

void QVector2D_Normalize(void* ptr)
{
	static_cast<QVector2D*>(ptr)->normalize();
}

void QVector2D_SetX(void* ptr, float x)
{
	static_cast<QVector2D*>(ptr)->setX(x);
}

void QVector2D_SetY(void* ptr, float y)
{
	static_cast<QVector2D*>(ptr)->setY(y);
}

void* QVector2D_ToPoint(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QVector2D*>(ptr)->toPoint(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QVector2D_ToPointF(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QVector2D*>(ptr)->toPointF(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QVector2D_Normalized(void* ptr)
{
	return new QVector2D(static_cast<QVector2D*>(ptr)->normalized());
}

void* QVector2D_ToVector3D(void* ptr)
{
	return new QVector3D(static_cast<QVector2D*>(ptr)->toVector3D());
}

void* QVector2D_ToVector4D(void* ptr)
{
	return new QVector4D(static_cast<QVector2D*>(ptr)->toVector4D());
}

char QVector2D_IsNull(void* ptr)
{
	return static_cast<QVector2D*>(ptr)->isNull();
}

float QVector2D_DistanceToLine(void* ptr, void* point, void* direction)
{
	return static_cast<QVector2D*>(ptr)->distanceToLine(*static_cast<QVector2D*>(point), *static_cast<QVector2D*>(direction));
}

float QVector2D_DistanceToPoint(void* ptr, void* point)
{
	return static_cast<QVector2D*>(ptr)->distanceToPoint(*static_cast<QVector2D*>(point));
}

float QVector2D_Length(void* ptr)
{
	return static_cast<QVector2D*>(ptr)->length();
}

float QVector2D_LengthSquared(void* ptr)
{
	return static_cast<QVector2D*>(ptr)->lengthSquared();
}

float QVector2D_X(void* ptr)
{
	return static_cast<QVector2D*>(ptr)->x();
}

float QVector2D_Y(void* ptr)
{
	return static_cast<QVector2D*>(ptr)->y();
}

void* QVector3D_QVector3D_CrossProduct(void* v1, void* v2)
{
	return new QVector3D(QVector3D::crossProduct(*static_cast<QVector3D*>(v1), *static_cast<QVector3D*>(v2)));
}

void* QVector3D_QVector3D_Normal(void* v1, void* v2)
{
	return new QVector3D(QVector3D::normal(*static_cast<QVector3D*>(v1), *static_cast<QVector3D*>(v2)));
}

void* QVector3D_QVector3D_Normal2(void* v1, void* v2, void* v3)
{
	return new QVector3D(QVector3D::normal(*static_cast<QVector3D*>(v1), *static_cast<QVector3D*>(v2), *static_cast<QVector3D*>(v3)));
}

void* QVector3D_NewQVector3D()
{
	return new QVector3D();
}

void* QVector3D_NewQVector3D4(void* point)
{
	return new QVector3D(*static_cast<QPoint*>(point));
}

void* QVector3D_NewQVector3D5(void* point)
{
	return new QVector3D(*static_cast<QPointF*>(point));
}

void* QVector3D_NewQVector3D6(void* vector)
{
	return new QVector3D(*static_cast<QVector2D*>(vector));
}

void* QVector3D_NewQVector3D7(void* vector, float zpos)
{
	return new QVector3D(*static_cast<QVector2D*>(vector), zpos);
}

void* QVector3D_NewQVector3D8(void* vector)
{
	return new QVector3D(*static_cast<QVector4D*>(vector));
}

void* QVector3D_NewQVector3D3(float xpos, float ypos, float zpos)
{
	return new QVector3D(xpos, ypos, zpos);
}

float QVector3D_QVector3D_DotProduct(void* v1, void* v2)
{
	return QVector3D::dotProduct(*static_cast<QVector3D*>(v1), *static_cast<QVector3D*>(v2));
}

void QVector3D_Normalize(void* ptr)
{
	static_cast<QVector3D*>(ptr)->normalize();
}

void QVector3D_SetX(void* ptr, float x)
{
	static_cast<QVector3D*>(ptr)->setX(x);
}

void QVector3D_SetY(void* ptr, float y)
{
	static_cast<QVector3D*>(ptr)->setY(y);
}

void QVector3D_SetZ(void* ptr, float z)
{
	static_cast<QVector3D*>(ptr)->setZ(z);
}

void* QVector3D_ToPoint(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QVector3D*>(ptr)->toPoint(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QVector3D_ToPointF(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QVector3D*>(ptr)->toPointF(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QVector3D_ToVector2D(void* ptr)
{
	return new QVector2D(static_cast<QVector3D*>(ptr)->toVector2D());
}

void* QVector3D_Normalized(void* ptr)
{
	return new QVector3D(static_cast<QVector3D*>(ptr)->normalized());
}

void* QVector3D_Project(void* ptr, void* modelView, void* projection, void* viewport)
{
	return new QVector3D(static_cast<QVector3D*>(ptr)->project(*static_cast<QMatrix4x4*>(modelView), *static_cast<QMatrix4x4*>(projection), *static_cast<QRect*>(viewport)));
}

void* QVector3D_Unproject(void* ptr, void* modelView, void* projection, void* viewport)
{
	return new QVector3D(static_cast<QVector3D*>(ptr)->unproject(*static_cast<QMatrix4x4*>(modelView), *static_cast<QMatrix4x4*>(projection), *static_cast<QRect*>(viewport)));
}

void* QVector3D_ToVector4D(void* ptr)
{
	return new QVector4D(static_cast<QVector3D*>(ptr)->toVector4D());
}

char QVector3D_IsNull(void* ptr)
{
	return static_cast<QVector3D*>(ptr)->isNull();
}

float QVector3D_DistanceToLine(void* ptr, void* point, void* direction)
{
	return static_cast<QVector3D*>(ptr)->distanceToLine(*static_cast<QVector3D*>(point), *static_cast<QVector3D*>(direction));
}

float QVector3D_DistanceToPlane(void* ptr, void* plane, void* normal)
{
	return static_cast<QVector3D*>(ptr)->distanceToPlane(*static_cast<QVector3D*>(plane), *static_cast<QVector3D*>(normal));
}

float QVector3D_DistanceToPlane2(void* ptr, void* plane1, void* plane2, void* plane3)
{
	return static_cast<QVector3D*>(ptr)->distanceToPlane(*static_cast<QVector3D*>(plane1), *static_cast<QVector3D*>(plane2), *static_cast<QVector3D*>(plane3));
}

float QVector3D_DistanceToPoint(void* ptr, void* point)
{
	return static_cast<QVector3D*>(ptr)->distanceToPoint(*static_cast<QVector3D*>(point));
}

float QVector3D_Length(void* ptr)
{
	return static_cast<QVector3D*>(ptr)->length();
}

float QVector3D_LengthSquared(void* ptr)
{
	return static_cast<QVector3D*>(ptr)->lengthSquared();
}

float QVector3D_X(void* ptr)
{
	return static_cast<QVector3D*>(ptr)->x();
}

float QVector3D_Y(void* ptr)
{
	return static_cast<QVector3D*>(ptr)->y();
}

float QVector3D_Z(void* ptr)
{
	return static_cast<QVector3D*>(ptr)->z();
}

void* QVector4D_NewQVector4D()
{
	return new QVector4D();
}

void* QVector4D_NewQVector4D4(void* point)
{
	return new QVector4D(*static_cast<QPoint*>(point));
}

void* QVector4D_NewQVector4D5(void* point)
{
	return new QVector4D(*static_cast<QPointF*>(point));
}

void* QVector4D_NewQVector4D6(void* vector)
{
	return new QVector4D(*static_cast<QVector2D*>(vector));
}

void* QVector4D_NewQVector4D7(void* vector, float zpos, float wpos)
{
	return new QVector4D(*static_cast<QVector2D*>(vector), zpos, wpos);
}

void* QVector4D_NewQVector4D8(void* vector)
{
	return new QVector4D(*static_cast<QVector3D*>(vector));
}

void* QVector4D_NewQVector4D9(void* vector, float wpos)
{
	return new QVector4D(*static_cast<QVector3D*>(vector), wpos);
}

void* QVector4D_NewQVector4D3(float xpos, float ypos, float zpos, float wpos)
{
	return new QVector4D(xpos, ypos, zpos, wpos);
}

float QVector4D_QVector4D_DotProduct(void* v1, void* v2)
{
	return QVector4D::dotProduct(*static_cast<QVector4D*>(v1), *static_cast<QVector4D*>(v2));
}

void QVector4D_Normalize(void* ptr)
{
	static_cast<QVector4D*>(ptr)->normalize();
}

void QVector4D_SetW(void* ptr, float w)
{
	static_cast<QVector4D*>(ptr)->setW(w);
}

void QVector4D_SetX(void* ptr, float x)
{
	static_cast<QVector4D*>(ptr)->setX(x);
}

void QVector4D_SetY(void* ptr, float y)
{
	static_cast<QVector4D*>(ptr)->setY(y);
}

void QVector4D_SetZ(void* ptr, float z)
{
	static_cast<QVector4D*>(ptr)->setZ(z);
}

void* QVector4D_ToPoint(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QVector4D*>(ptr)->toPoint(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QVector4D_ToPointF(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QVector4D*>(ptr)->toPointF(); new QPointF(tmpValue.x(), tmpValue.y()); });
}

void* QVector4D_ToVector2D(void* ptr)
{
	return new QVector2D(static_cast<QVector4D*>(ptr)->toVector2D());
}

void* QVector4D_ToVector2DAffine(void* ptr)
{
	return new QVector2D(static_cast<QVector4D*>(ptr)->toVector2DAffine());
}

void* QVector4D_ToVector3D(void* ptr)
{
	return new QVector3D(static_cast<QVector4D*>(ptr)->toVector3D());
}

void* QVector4D_ToVector3DAffine(void* ptr)
{
	return new QVector3D(static_cast<QVector4D*>(ptr)->toVector3DAffine());
}

void* QVector4D_Normalized(void* ptr)
{
	return new QVector4D(static_cast<QVector4D*>(ptr)->normalized());
}

char QVector4D_IsNull(void* ptr)
{
	return static_cast<QVector4D*>(ptr)->isNull();
}

float QVector4D_Length(void* ptr)
{
	return static_cast<QVector4D*>(ptr)->length();
}

float QVector4D_LengthSquared(void* ptr)
{
	return static_cast<QVector4D*>(ptr)->lengthSquared();
}

float QVector4D_W(void* ptr)
{
	return static_cast<QVector4D*>(ptr)->w();
}

float QVector4D_X(void* ptr)
{
	return static_cast<QVector4D*>(ptr)->x();
}

float QVector4D_Y(void* ptr)
{
	return static_cast<QVector4D*>(ptr)->y();
}

float QVector4D_Z(void* ptr)
{
	return static_cast<QVector4D*>(ptr)->z();
}

class MyQWhatsThisClickedEvent: public QWhatsThisClickedEvent
{
public:
	MyQWhatsThisClickedEvent(const QString &href) : QWhatsThisClickedEvent(href) {};
};

void* QWhatsThisClickedEvent_NewQWhatsThisClickedEvent(char* href)
{
	return new MyQWhatsThisClickedEvent(QString(href));
}

struct QtGui_PackedString QWhatsThisClickedEvent_Href(void* ptr)
{
	return ({ QByteArray tc87a51 = static_cast<QWhatsThisClickedEvent*>(ptr)->href().toUtf8(); QtGui_PackedString { const_cast<char*>(tc87a51.prepend("WHITESPACE").constData()+10), tc87a51.size()-10 }; });
}

class MyQWheelEvent: public QWheelEvent
{
public:
	MyQWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) : QWheelEvent(pos, globalPos, pixelDelta, angleDelta, qt4Delta, qt4Orientation, buttons, modifiers) {};
	MyQWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase) : QWheelEvent(pos, globalPos, pixelDelta, angleDelta, qt4Delta, qt4Orientation, buttons, modifiers, phase) {};
	MyQWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source) : QWheelEvent(pos, globalPos, pixelDelta, angleDelta, qt4Delta, qt4Orientation, buttons, modifiers, phase, source) {};
	MyQWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source, bool inverted) : QWheelEvent(pos, globalPos, pixelDelta, angleDelta, qt4Delta, qt4Orientation, buttons, modifiers, phase, source, inverted) {};
};

void* QWheelEvent_NewQWheelEvent(void* pos, void* globalPos, void* pixelDelta, void* angleDelta, int qt4Delta, long long qt4Orientation, long long buttons, long long modifiers)
{
	return new MyQWheelEvent(*static_cast<QPointF*>(pos), *static_cast<QPointF*>(globalPos), *static_cast<QPoint*>(pixelDelta), *static_cast<QPoint*>(angleDelta), qt4Delta, static_cast<Qt::Orientation>(qt4Orientation), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers));
}

void* QWheelEvent_NewQWheelEvent4(void* pos, void* globalPos, void* pixelDelta, void* angleDelta, int qt4Delta, long long qt4Orientation, long long buttons, long long modifiers, long long phase)
{
	return new MyQWheelEvent(*static_cast<QPointF*>(pos), *static_cast<QPointF*>(globalPos), *static_cast<QPoint*>(pixelDelta), *static_cast<QPoint*>(angleDelta), qt4Delta, static_cast<Qt::Orientation>(qt4Orientation), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<Qt::ScrollPhase>(phase));
}

void* QWheelEvent_NewQWheelEvent5(void* pos, void* globalPos, void* pixelDelta, void* angleDelta, int qt4Delta, long long qt4Orientation, long long buttons, long long modifiers, long long phase, long long source)
{
	return new MyQWheelEvent(*static_cast<QPointF*>(pos), *static_cast<QPointF*>(globalPos), *static_cast<QPoint*>(pixelDelta), *static_cast<QPoint*>(angleDelta), qt4Delta, static_cast<Qt::Orientation>(qt4Orientation), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<Qt::ScrollPhase>(phase), static_cast<Qt::MouseEventSource>(source));
}

void* QWheelEvent_NewQWheelEvent6(void* pos, void* globalPos, void* pixelDelta, void* angleDelta, int qt4Delta, long long qt4Orientation, long long buttons, long long modifiers, long long phase, long long source, char inverted)
{
	return new MyQWheelEvent(*static_cast<QPointF*>(pos), *static_cast<QPointF*>(globalPos), *static_cast<QPoint*>(pixelDelta), *static_cast<QPoint*>(angleDelta), qt4Delta, static_cast<Qt::Orientation>(qt4Orientation), static_cast<Qt::MouseButton>(buttons), static_cast<Qt::KeyboardModifier>(modifiers), static_cast<Qt::ScrollPhase>(phase), static_cast<Qt::MouseEventSource>(source), inverted != 0);
}

void* QWheelEvent_AngleDelta(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->angleDelta(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QWheelEvent_GlobalPos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->globalPos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QWheelEvent_PixelDelta(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->pixelDelta(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

void* QWheelEvent_Pos(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->pos(); new QPoint(tmpValue.x(), tmpValue.y()); });
}

long long QWheelEvent_Buttons(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->buttons();
}

long long QWheelEvent_Source(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->source();
}

long long QWheelEvent_Phase(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->phase();
}

char QWheelEvent_Inverted(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->inverted();
}

void* QWheelEvent_GlobalPosF(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QWheelEvent*>(ptr)->globalPosF());
}

void* QWheelEvent_PosF(void* ptr)
{
	return const_cast<QPointF*>(&static_cast<QWheelEvent*>(ptr)->posF());
}

int QWheelEvent_GlobalX(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->globalX();
}

int QWheelEvent_GlobalY(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->globalY();
}

int QWheelEvent_X(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->x();
}

int QWheelEvent_Y(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->y();
}

int QWheelEvent_QWheelEvent_DefaultDeltasPerStep()
{
	return QWheelEvent::DefaultDeltasPerStep;
}

void* QWheelEvent_AngleD(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->angleD; new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QWheelEvent_SetAngleD(void* ptr, void* vqp)
{
	static_cast<QWheelEvent*>(ptr)->angleD = *static_cast<QPoint*>(vqp);
}

void* QWheelEvent_G(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QWheelEvent*>(ptr)->g; new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QWheelEvent_SetG(void* ptr, void* vqp)
{
	static_cast<QWheelEvent*>(ptr)->g = *static_cast<QPointF*>(vqp);
}

long long QWheelEvent_MouseState(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->mouseState;
}

void QWheelEvent_SetMouseState(void* ptr, long long vqt)
{
	static_cast<QWheelEvent*>(ptr)->mouseState = static_cast<Qt::MouseButton>(vqt);
}

void* QWheelEvent_P(void* ptr)
{
	return ({ QPointF tmpValue = static_cast<QWheelEvent*>(ptr)->p; new QPointF(tmpValue.x(), tmpValue.y()); });
}

void QWheelEvent_SetP(void* ptr, void* vqp)
{
	static_cast<QWheelEvent*>(ptr)->p = *static_cast<QPointF*>(vqp);
}

void* QWheelEvent_PixelD(void* ptr)
{
	return ({ QPoint tmpValue = static_cast<QWheelEvent*>(ptr)->pixelD; new QPoint(tmpValue.x(), tmpValue.y()); });
}

void QWheelEvent_SetPixelD(void* ptr, void* vqp)
{
	static_cast<QWheelEvent*>(ptr)->pixelD = *static_cast<QPoint*>(vqp);
}

int QWheelEvent_Qt4D(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->qt4D;
}

void QWheelEvent_SetQt4D(void* ptr, int vin)
{
	static_cast<QWheelEvent*>(ptr)->qt4D = vin;
}

long long QWheelEvent_Qt4O(void* ptr)
{
	return static_cast<QWheelEvent*>(ptr)->qt4O;
}

void QWheelEvent_SetQt4O(void* ptr, long long vqt)
{
	static_cast<QWheelEvent*>(ptr)->qt4O = static_cast<Qt::Orientation>(vqt);
}

class MyQWindow: public QWindow
{
public:
	MyQWindow(QScreen *targetScreen) : QWindow(targetScreen) {};
	MyQWindow(QWindow *parent) : QWindow(parent) {};
	bool close() { return callbackQWindow_Close(this) != 0; };
	bool event(QEvent * ev) { return callbackQWindow_Event(this, ev) != 0; };
	bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQWindow_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, *result) != 0; };
	void Signal_ActiveChanged() { callbackQWindow_ActiveChanged(this); };
	void alert(int msec) { callbackQWindow_Alert(this, msec); };
	void Signal_ContentOrientationChanged(Qt::ScreenOrientation orientation) { callbackQWindow_ContentOrientationChanged(this, orientation); };
	void exposeEvent(QExposeEvent * ev) { callbackQWindow_ExposeEvent(this, ev); };
	void focusInEvent(QFocusEvent * ev) { callbackQWindow_FocusInEvent(this, ev); };
	void Signal_FocusObjectChanged(QObject * object) { callbackQWindow_FocusObjectChanged(this, object); };
	void focusOutEvent(QFocusEvent * ev) { callbackQWindow_FocusOutEvent(this, ev); };
	void Signal_HeightChanged(int arg) { callbackQWindow_HeightChanged(this, arg); };
	void hide() { callbackQWindow_Hide(this); };
	void hideEvent(QHideEvent * ev) { callbackQWindow_HideEvent(this, ev); };
	void keyPressEvent(QKeyEvent * ev) { callbackQWindow_KeyPressEvent(this, ev); };
	void keyReleaseEvent(QKeyEvent * ev) { callbackQWindow_KeyReleaseEvent(this, ev); };
	void lower() { callbackQWindow_Lower(this); };
	void Signal_MaximumHeightChanged(int arg) { callbackQWindow_MaximumHeightChanged(this, arg); };
	void Signal_MaximumWidthChanged(int arg) { callbackQWindow_MaximumWidthChanged(this, arg); };
	void Signal_MinimumHeightChanged(int arg) { callbackQWindow_MinimumHeightChanged(this, arg); };
	void Signal_MinimumWidthChanged(int arg) { callbackQWindow_MinimumWidthChanged(this, arg); };
	void Signal_ModalityChanged(Qt::WindowModality modality) { callbackQWindow_ModalityChanged(this, modality); };
	void mouseDoubleClickEvent(QMouseEvent * ev) { callbackQWindow_MouseDoubleClickEvent(this, ev); };
	void mouseMoveEvent(QMouseEvent * ev) { callbackQWindow_MouseMoveEvent(this, ev); };
	void mousePressEvent(QMouseEvent * ev) { callbackQWindow_MousePressEvent(this, ev); };
	void mouseReleaseEvent(QMouseEvent * ev) { callbackQWindow_MouseReleaseEvent(this, ev); };
	void moveEvent(QMoveEvent * ev) { callbackQWindow_MoveEvent(this, ev); };
	void Signal_OpacityChanged(qreal opacity) { callbackQWindow_OpacityChanged(this, opacity); };
	void raise() { callbackQWindow_Raise(this); };
	void requestActivate() { callbackQWindow_RequestActivate(this); };
	void requestUpdate() { callbackQWindow_RequestUpdate(this); };
	void resizeEvent(QResizeEvent * ev) { callbackQWindow_ResizeEvent(this, ev); };
	void Signal_ScreenChanged(QScreen * screen) { callbackQWindow_ScreenChanged(this, screen); };
	void setHeight(int arg) { callbackQWindow_SetHeight(this, arg); };
	void setMaximumHeight(int h) { callbackQWindow_SetMaximumHeight(this, h); };
	void setMaximumWidth(int w) { callbackQWindow_SetMaximumWidth(this, w); };
	void setMinimumHeight(int h) { callbackQWindow_SetMinimumHeight(this, h); };
	void setMinimumWidth(int w) { callbackQWindow_SetMinimumWidth(this, w); };
	void setTitle(const QString & vqs) { QByteArray tda39a3 = vqs.toUtf8(); QtGui_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };callbackQWindow_SetTitle(this, vqsPacked); };
	void setVisible(bool visible) { callbackQWindow_SetVisible(this, visible); };
	void setWidth(int arg) { callbackQWindow_SetWidth(this, arg); };
	void setX(int arg) { callbackQWindow_SetX(this, arg); };
	void setY(int arg) { callbackQWindow_SetY(this, arg); };
	void show() { callbackQWindow_Show(this); };
	void showEvent(QShowEvent * ev) { callbackQWindow_ShowEvent(this, ev); };
	void showFullScreen() { callbackQWindow_ShowFullScreen(this); };
	void showMaximized() { callbackQWindow_ShowMaximized(this); };
	void showMinimized() { callbackQWindow_ShowMinimized(this); };
	void showNormal() { callbackQWindow_ShowNormal(this); };
	void tabletEvent(QTabletEvent * ev) { callbackQWindow_TabletEvent(this, ev); };
	void touchEvent(QTouchEvent * ev) { callbackQWindow_TouchEvent(this, ev); };
	void Signal_VisibilityChanged(QWindow::Visibility visibility) { callbackQWindow_VisibilityChanged(this, visibility); };
	void Signal_VisibleChanged(bool arg) { callbackQWindow_VisibleChanged(this, arg); };
	void wheelEvent(QWheelEvent * ev) { callbackQWindow_WheelEvent(this, ev); };
	void Signal_WidthChanged(int arg) { callbackQWindow_WidthChanged(this, arg); };
	void Signal_WindowStateChanged(Qt::WindowState windowState) { callbackQWindow_WindowStateChanged(this, windowState); };
	void Signal_WindowTitleChanged(const QString & title) { QByteArray t3c6de1 = title.toUtf8(); QtGui_PackedString titlePacked = { const_cast<char*>(t3c6de1.prepend("WHITESPACE").constData()+10), t3c6de1.size()-10 };callbackQWindow_WindowTitleChanged(this, titlePacked); };
	void Signal_XChanged(int arg) { callbackQWindow_XChanged(this, arg); };
	void Signal_YChanged(int arg) { callbackQWindow_YChanged(this, arg); };
	 ~MyQWindow() { callbackQWindow_DestroyQWindow(this); };
	QObject * focusObject() const { return static_cast<QObject*>(callbackQWindow_FocusObject(const_cast<void*>(static_cast<const void*>(this)))); };
	QSize size() const { return *static_cast<QSize*>(callbackQWindow_Size(const_cast<void*>(static_cast<const void*>(this)))); };
	QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQWindow_Format(const_cast<void*>(static_cast<const void*>(this)))); };
	SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQWindow_SurfaceType(const_cast<void*>(static_cast<const void*>(this)))); };
	bool eventFilter(QObject * watched, QEvent * event) { return callbackQWindow_EventFilter(this, watched, event) != 0; };
	void childEvent(QChildEvent * event) { callbackQWindow_ChildEvent(this, event); };
	void connectNotify(const QMetaMethod & sign) { callbackQWindow_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void customEvent(QEvent * event) { callbackQWindow_CustomEvent(this, event); };
	void deleteLater() { callbackQWindow_DeleteLater(this); };
	void Signal_Destroyed(QObject * obj) { callbackQWindow_Destroyed(this, obj); };
	void disconnectNotify(const QMetaMethod & sign) { callbackQWindow_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); QtGui_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQWindow_ObjectNameChanged(this, objectNamePacked); };
	void timerEvent(QTimerEvent * event) { callbackQWindow_TimerEvent(this, event); };
	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWindow_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};

void* QWindow_QWindow_FromWinId(uintptr_t id)
{
		return QWindow::fromWinId(id);
}

void* QWindow_NewQWindow(void* targetScreen)
{
	return new MyQWindow(static_cast<QScreen*>(targetScreen));
}

void* QWindow_NewQWindow2(void* parent)
{
	return new MyQWindow(static_cast<QWindow*>(parent));
}

char QWindow_Close(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
			bool returnArg;
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
		return returnArg;
	} else {
			bool returnArg;
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "close", Q_RETURN_ARG(bool, returnArg));
		return returnArg;
	}
}

char QWindow_CloseDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRasterWindow*>(ptr)->QRasterWindow::close();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::close();
	} else {
		return static_cast<QWindow*>(ptr)->QWindow::close();
	}
}

char QWindow_Event(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->event(static_cast<QEvent*>(ev));
	} else {
		return static_cast<QWindow*>(ptr)->event(static_cast<QEvent*>(ev));
	}
}

char QWindow_EventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRasterWindow*>(ptr)->QRasterWindow::event(static_cast<QEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::event(static_cast<QEvent*>(ev));
	} else {
		return static_cast<QWindow*>(ptr)->QWindow::event(static_cast<QEvent*>(ev));
	}
}

char QWindow_NativeEvent(void* ptr, void* eventType, void* message, long result)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->nativeEvent(*static_cast<QByteArray*>(eventType), message, &result);
	} else {
		return static_cast<QWindow*>(ptr)->nativeEvent(*static_cast<QByteArray*>(eventType), message, &result);
	}
}

char QWindow_NativeEventDefault(void* ptr, void* eventType, void* message, long result)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRasterWindow*>(ptr)->QRasterWindow::nativeEvent(*static_cast<QByteArray*>(eventType), message, &result);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::nativeEvent(*static_cast<QByteArray*>(eventType), message, &result);
	} else {
		return static_cast<QWindow*>(ptr)->QWindow::nativeEvent(*static_cast<QByteArray*>(eventType), message, &result);
	}
}

char QWindow_SetKeyboardGrabEnabled(void* ptr, char grab)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->setKeyboardGrabEnabled(grab != 0);
	} else {
		return static_cast<QWindow*>(ptr)->setKeyboardGrabEnabled(grab != 0);
	}
}

char QWindow_SetMouseGrabEnabled(void* ptr, char grab)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->setMouseGrabEnabled(grab != 0);
	} else {
		return static_cast<QWindow*>(ptr)->setMouseGrabEnabled(grab != 0);
	}
}

void QWindow_ConnectActiveChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)()>(&QWindow::activeChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)()>(&MyQWindow::Signal_ActiveChanged));
}

void QWindow_DisconnectActiveChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)()>(&QWindow::activeChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)()>(&MyQWindow::Signal_ActiveChanged));
}

void QWindow_ActiveChanged(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->activeChanged();
	} else {
		static_cast<QWindow*>(ptr)->activeChanged();
	}
}

void QWindow_Alert(void* ptr, int msec)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "alert", Q_ARG(int, msec));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "alert", Q_ARG(int, msec));
	}
}

void QWindow_AlertDefault(void* ptr, int msec)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::alert(msec);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::alert(msec);
	} else {
		static_cast<QWindow*>(ptr)->QWindow::alert(msec);
	}
}

void QWindow_ConnectContentOrientationChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::ScreenOrientation)>(&QWindow::contentOrientationChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::ScreenOrientation)>(&MyQWindow::Signal_ContentOrientationChanged));
}

void QWindow_DisconnectContentOrientationChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::ScreenOrientation)>(&QWindow::contentOrientationChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::ScreenOrientation)>(&MyQWindow::Signal_ContentOrientationChanged));
}

void QWindow_ContentOrientationChanged(void* ptr, long long orientation)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->contentOrientationChanged(static_cast<Qt::ScreenOrientation>(orientation));
	} else {
		static_cast<QWindow*>(ptr)->contentOrientationChanged(static_cast<Qt::ScreenOrientation>(orientation));
	}
}

void QWindow_Create(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->create();
	} else {
		static_cast<QWindow*>(ptr)->create();
	}
}

void QWindow_Destroy(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->destroy();
	} else {
		static_cast<QWindow*>(ptr)->destroy();
	}
}

void QWindow_ExposeEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->exposeEvent(static_cast<QExposeEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->exposeEvent(static_cast<QExposeEvent*>(ev));
	}
}

void QWindow_ExposeEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::exposeEvent(static_cast<QExposeEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::exposeEvent(static_cast<QExposeEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::exposeEvent(static_cast<QExposeEvent*>(ev));
	}
}

void QWindow_FocusInEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(ev));
	}
}

void QWindow_FocusInEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::focusInEvent(static_cast<QFocusEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::focusInEvent(static_cast<QFocusEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::focusInEvent(static_cast<QFocusEvent*>(ev));
	}
}

void QWindow_ConnectFocusObjectChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QObject *)>(&QWindow::focusObjectChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QObject *)>(&MyQWindow::Signal_FocusObjectChanged));
}

void QWindow_DisconnectFocusObjectChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QObject *)>(&QWindow::focusObjectChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QObject *)>(&MyQWindow::Signal_FocusObjectChanged));
}

void QWindow_FocusObjectChanged(void* ptr, void* object)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
			static_cast<QPaintDeviceWindow*>(ptr)->focusObjectChanged(static_cast<QOffscreenSurface*>(object));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
			static_cast<QPaintDeviceWindow*>(ptr)->focusObjectChanged(static_cast<QPaintDeviceWindow*>(object));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
			static_cast<QPaintDeviceWindow*>(ptr)->focusObjectChanged(static_cast<QPdfWriter*>(object));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
			static_cast<QPaintDeviceWindow*>(ptr)->focusObjectChanged(static_cast<QWindow*>(object));
		} else {
			static_cast<QPaintDeviceWindow*>(ptr)->focusObjectChanged(static_cast<QObject*>(object));
		}
	} else {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
			static_cast<QWindow*>(ptr)->focusObjectChanged(static_cast<QOffscreenSurface*>(object));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
			static_cast<QWindow*>(ptr)->focusObjectChanged(static_cast<QPaintDeviceWindow*>(object));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
			static_cast<QWindow*>(ptr)->focusObjectChanged(static_cast<QPdfWriter*>(object));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
			static_cast<QWindow*>(ptr)->focusObjectChanged(static_cast<QWindow*>(object));
		} else {
			static_cast<QWindow*>(ptr)->focusObjectChanged(static_cast<QObject*>(object));
		}
	}
}

void QWindow_FocusOutEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(ev));
	}
}

void QWindow_FocusOutEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::focusOutEvent(static_cast<QFocusEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::focusOutEvent(static_cast<QFocusEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::focusOutEvent(static_cast<QFocusEvent*>(ev));
	}
}

void QWindow_ConnectHeightChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::heightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_HeightChanged));
}

void QWindow_DisconnectHeightChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::heightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_HeightChanged));
}

void QWindow_HeightChanged(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->heightChanged(arg);
	} else {
		static_cast<QWindow*>(ptr)->heightChanged(arg);
	}
}

void QWindow_Hide(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "hide");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "hide");
	}
}

void QWindow_HideDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::hide();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::hide();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::hide();
	}
}

void QWindow_HideEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->hideEvent(static_cast<QHideEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->hideEvent(static_cast<QHideEvent*>(ev));
	}
}

void QWindow_HideEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::hideEvent(static_cast<QHideEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::hideEvent(static_cast<QHideEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::hideEvent(static_cast<QHideEvent*>(ev));
	}
}

void QWindow_KeyPressEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->keyPressEvent(static_cast<QKeyEvent*>(ev));
	}
}

void QWindow_KeyPressEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::keyPressEvent(static_cast<QKeyEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::keyPressEvent(static_cast<QKeyEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::keyPressEvent(static_cast<QKeyEvent*>(ev));
	}
}

void QWindow_KeyReleaseEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->keyReleaseEvent(static_cast<QKeyEvent*>(ev));
	}
}

void QWindow_KeyReleaseEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::keyReleaseEvent(static_cast<QKeyEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::keyReleaseEvent(static_cast<QKeyEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::keyReleaseEvent(static_cast<QKeyEvent*>(ev));
	}
}

void QWindow_Lower(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "lower");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "lower");
	}
}

void QWindow_LowerDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::lower();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::lower();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::lower();
	}
}

void QWindow_ConnectMaximumHeightChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::maximumHeightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MaximumHeightChanged));
}

void QWindow_DisconnectMaximumHeightChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::maximumHeightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MaximumHeightChanged));
}

void QWindow_MaximumHeightChanged(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->maximumHeightChanged(arg);
	} else {
		static_cast<QWindow*>(ptr)->maximumHeightChanged(arg);
	}
}

void QWindow_ConnectMaximumWidthChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::maximumWidthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MaximumWidthChanged));
}

void QWindow_DisconnectMaximumWidthChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::maximumWidthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MaximumWidthChanged));
}

void QWindow_MaximumWidthChanged(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->maximumWidthChanged(arg);
	} else {
		static_cast<QWindow*>(ptr)->maximumWidthChanged(arg);
	}
}

void QWindow_ConnectMinimumHeightChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::minimumHeightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MinimumHeightChanged));
}

void QWindow_DisconnectMinimumHeightChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::minimumHeightChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MinimumHeightChanged));
}

void QWindow_MinimumHeightChanged(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->minimumHeightChanged(arg);
	} else {
		static_cast<QWindow*>(ptr)->minimumHeightChanged(arg);
	}
}

void QWindow_ConnectMinimumWidthChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::minimumWidthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MinimumWidthChanged));
}

void QWindow_DisconnectMinimumWidthChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::minimumWidthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_MinimumWidthChanged));
}

void QWindow_MinimumWidthChanged(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->minimumWidthChanged(arg);
	} else {
		static_cast<QWindow*>(ptr)->minimumWidthChanged(arg);
	}
}

void QWindow_ConnectModalityChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::WindowModality)>(&QWindow::modalityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::WindowModality)>(&MyQWindow::Signal_ModalityChanged));
}

void QWindow_DisconnectModalityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::WindowModality)>(&QWindow::modalityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::WindowModality)>(&MyQWindow::Signal_ModalityChanged));
}

void QWindow_ModalityChanged(void* ptr, long long modality)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->modalityChanged(static_cast<Qt::WindowModality>(modality));
	} else {
		static_cast<QWindow*>(ptr)->modalityChanged(static_cast<Qt::WindowModality>(modality));
	}
}

void QWindow_MouseDoubleClickEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
	}
}

void QWindow_MouseDoubleClickEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
	}
}

void QWindow_MouseMoveEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->mouseMoveEvent(static_cast<QMouseEvent*>(ev));
	}
}

void QWindow_MouseMoveEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::mouseMoveEvent(static_cast<QMouseEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::mouseMoveEvent(static_cast<QMouseEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::mouseMoveEvent(static_cast<QMouseEvent*>(ev));
	}
}

void QWindow_MousePressEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->mousePressEvent(static_cast<QMouseEvent*>(ev));
	}
}

void QWindow_MousePressEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::mousePressEvent(static_cast<QMouseEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::mousePressEvent(static_cast<QMouseEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::mousePressEvent(static_cast<QMouseEvent*>(ev));
	}
}

void QWindow_MouseReleaseEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
	}
}

void QWindow_MouseReleaseEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::mouseReleaseEvent(static_cast<QMouseEvent*>(ev));
	}
}

void QWindow_MoveEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->moveEvent(static_cast<QMoveEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->moveEvent(static_cast<QMoveEvent*>(ev));
	}
}

void QWindow_MoveEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::moveEvent(static_cast<QMoveEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::moveEvent(static_cast<QMoveEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::moveEvent(static_cast<QMoveEvent*>(ev));
	}
}

void QWindow_ConnectOpacityChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(qreal)>(&QWindow::opacityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(qreal)>(&MyQWindow::Signal_OpacityChanged));
}

void QWindow_DisconnectOpacityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(qreal)>(&QWindow::opacityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(qreal)>(&MyQWindow::Signal_OpacityChanged));
}

void QWindow_OpacityChanged(void* ptr, double opacity)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->opacityChanged(opacity);
	} else {
		static_cast<QWindow*>(ptr)->opacityChanged(opacity);
	}
}

void QWindow_Raise(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "raise");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "raise");
	}
}

void QWindow_RaiseDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::raise();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::raise();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::raise();
	}
}

void QWindow_ReportContentOrientationChange(void* ptr, long long orientation)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->reportContentOrientationChange(static_cast<Qt::ScreenOrientation>(orientation));
	} else {
		static_cast<QWindow*>(ptr)->reportContentOrientationChange(static_cast<Qt::ScreenOrientation>(orientation));
	}
}

void QWindow_RequestActivate(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "requestActivate");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "requestActivate");
	}
}

void QWindow_RequestActivateDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::requestActivate();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::requestActivate();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::requestActivate();
	}
}

void QWindow_RequestUpdate(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "requestUpdate");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "requestUpdate");
	}
}

void QWindow_RequestUpdateDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::requestUpdate();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::requestUpdate();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::requestUpdate();
	}
}

void QWindow_Resize(void* ptr, void* newSize)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->resize(*static_cast<QSize*>(newSize));
	} else {
		static_cast<QWindow*>(ptr)->resize(*static_cast<QSize*>(newSize));
	}
}

void QWindow_Resize2(void* ptr, int w, int h)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->resize(w, h);
	} else {
		static_cast<QWindow*>(ptr)->resize(w, h);
	}
}

void QWindow_ResizeEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(ev));
	}
}

void QWindow_ResizeEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::resizeEvent(static_cast<QResizeEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::resizeEvent(static_cast<QResizeEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::resizeEvent(static_cast<QResizeEvent*>(ev));
	}
}

void QWindow_ConnectScreenChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QScreen *)>(&QWindow::screenChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QScreen *)>(&MyQWindow::Signal_ScreenChanged));
}

void QWindow_DisconnectScreenChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QScreen *)>(&QWindow::screenChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QScreen *)>(&MyQWindow::Signal_ScreenChanged));
}

void QWindow_ScreenChanged(void* ptr, void* screen)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->screenChanged(static_cast<QScreen*>(screen));
	} else {
		static_cast<QWindow*>(ptr)->screenChanged(static_cast<QScreen*>(screen));
	}
}

void QWindow_SetBaseSize(void* ptr, void* size)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setBaseSize(*static_cast<QSize*>(size));
	} else {
		static_cast<QWindow*>(ptr)->setBaseSize(*static_cast<QSize*>(size));
	}
}

void QWindow_SetCursor(void* ptr, void* cursor)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setCursor(*static_cast<QCursor*>(cursor));
	} else {
		static_cast<QWindow*>(ptr)->setCursor(*static_cast<QCursor*>(cursor));
	}
}

void QWindow_SetFilePath(void* ptr, char* filePath)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setFilePath(QString(filePath));
	} else {
		static_cast<QWindow*>(ptr)->setFilePath(QString(filePath));
	}
}

void QWindow_SetFlags(void* ptr, long long flags)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setFlags(static_cast<Qt::WindowType>(flags));
	} else {
		static_cast<QWindow*>(ptr)->setFlags(static_cast<Qt::WindowType>(flags));
	}
}

void QWindow_SetFormat(void* ptr, void* format)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setFormat(*static_cast<QSurfaceFormat*>(format));
	} else {
		static_cast<QWindow*>(ptr)->setFormat(*static_cast<QSurfaceFormat*>(format));
	}
}

void QWindow_SetFramePosition(void* ptr, void* point)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setFramePosition(*static_cast<QPoint*>(point));
	} else {
		static_cast<QWindow*>(ptr)->setFramePosition(*static_cast<QPoint*>(point));
	}
}

void QWindow_SetGeometry2(void* ptr, void* rect)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setGeometry(*static_cast<QRect*>(rect));
	} else {
		static_cast<QWindow*>(ptr)->setGeometry(*static_cast<QRect*>(rect));
	}
}

void QWindow_SetGeometry(void* ptr, int posx, int posy, int w, int h)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setGeometry(posx, posy, w, h);
	} else {
		static_cast<QWindow*>(ptr)->setGeometry(posx, posy, w, h);
	}
}

void QWindow_SetHeight(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setHeight", Q_ARG(int, arg));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setHeight", Q_ARG(int, arg));
	}
}

void QWindow_SetHeightDefault(void* ptr, int arg)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::setHeight(arg);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setHeight(arg);
	} else {
		static_cast<QWindow*>(ptr)->QWindow::setHeight(arg);
	}
}

void QWindow_SetIcon(void* ptr, void* icon)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
	} else {
		static_cast<QWindow*>(ptr)->setIcon(*static_cast<QIcon*>(icon));
	}
}

void QWindow_SetMask(void* ptr, void* region)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setMask(*static_cast<QRegion*>(region));
	} else {
		static_cast<QWindow*>(ptr)->setMask(*static_cast<QRegion*>(region));
	}
}

void QWindow_SetMaximumHeight(void* ptr, int h)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setMaximumHeight", Q_ARG(int, h));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setMaximumHeight", Q_ARG(int, h));
	}
}

void QWindow_SetMaximumHeightDefault(void* ptr, int h)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::setMaximumHeight(h);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setMaximumHeight(h);
	} else {
		static_cast<QWindow*>(ptr)->QWindow::setMaximumHeight(h);
	}
}

void QWindow_SetMaximumSize(void* ptr, void* size)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setMaximumSize(*static_cast<QSize*>(size));
	} else {
		static_cast<QWindow*>(ptr)->setMaximumSize(*static_cast<QSize*>(size));
	}
}

void QWindow_SetMaximumWidth(void* ptr, int w)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setMaximumWidth", Q_ARG(int, w));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setMaximumWidth", Q_ARG(int, w));
	}
}

void QWindow_SetMaximumWidthDefault(void* ptr, int w)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::setMaximumWidth(w);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setMaximumWidth(w);
	} else {
		static_cast<QWindow*>(ptr)->QWindow::setMaximumWidth(w);
	}
}

void QWindow_SetMinimumHeight(void* ptr, int h)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setMinimumHeight", Q_ARG(int, h));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setMinimumHeight", Q_ARG(int, h));
	}
}

void QWindow_SetMinimumHeightDefault(void* ptr, int h)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::setMinimumHeight(h);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setMinimumHeight(h);
	} else {
		static_cast<QWindow*>(ptr)->QWindow::setMinimumHeight(h);
	}
}

void QWindow_SetMinimumSize(void* ptr, void* size)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setMinimumSize(*static_cast<QSize*>(size));
	} else {
		static_cast<QWindow*>(ptr)->setMinimumSize(*static_cast<QSize*>(size));
	}
}

void QWindow_SetMinimumWidth(void* ptr, int w)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setMinimumWidth", Q_ARG(int, w));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setMinimumWidth", Q_ARG(int, w));
	}
}

void QWindow_SetMinimumWidthDefault(void* ptr, int w)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::setMinimumWidth(w);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setMinimumWidth(w);
	} else {
		static_cast<QWindow*>(ptr)->QWindow::setMinimumWidth(w);
	}
}

void QWindow_SetModality(void* ptr, long long modality)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setModality(static_cast<Qt::WindowModality>(modality));
	} else {
		static_cast<QWindow*>(ptr)->setModality(static_cast<Qt::WindowModality>(modality));
	}
}

void QWindow_SetOpacity(void* ptr, double level)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setOpacity(level);
	} else {
		static_cast<QWindow*>(ptr)->setOpacity(level);
	}
}

void QWindow_SetParent(void* ptr, void* parent)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
			static_cast<QPaintDeviceWindow*>(ptr)->setParent(static_cast<QPaintDeviceWindow*>(parent));
		} else {
			static_cast<QPaintDeviceWindow*>(ptr)->setParent(static_cast<QWindow*>(parent));
		}
	} else {
		if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
			static_cast<QWindow*>(ptr)->setParent(static_cast<QPaintDeviceWindow*>(parent));
		} else {
			static_cast<QWindow*>(ptr)->setParent(static_cast<QWindow*>(parent));
		}
	}
}

void QWindow_SetPosition(void* ptr, void* pt)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setPosition(*static_cast<QPoint*>(pt));
	} else {
		static_cast<QWindow*>(ptr)->setPosition(*static_cast<QPoint*>(pt));
	}
}

void QWindow_SetPosition2(void* ptr, int posx, int posy)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setPosition(posx, posy);
	} else {
		static_cast<QWindow*>(ptr)->setPosition(posx, posy);
	}
}

void QWindow_SetScreen(void* ptr, void* newScreen)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setScreen(static_cast<QScreen*>(newScreen));
	} else {
		static_cast<QWindow*>(ptr)->setScreen(static_cast<QScreen*>(newScreen));
	}
}

void QWindow_SetSizeIncrement(void* ptr, void* size)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setSizeIncrement(*static_cast<QSize*>(size));
	} else {
		static_cast<QWindow*>(ptr)->setSizeIncrement(*static_cast<QSize*>(size));
	}
}

void QWindow_SetSurfaceType(void* ptr, long long surfaceType)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setSurfaceType(static_cast<QSurface::SurfaceType>(surfaceType));
	} else {
		static_cast<QWindow*>(ptr)->setSurfaceType(static_cast<QSurface::SurfaceType>(surfaceType));
	}
}

void QWindow_SetTitle(void* ptr, char* vqs)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setTitle", Q_ARG(QString, QString(vqs)));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setTitle", Q_ARG(QString, QString(vqs)));
	}
}

void QWindow_SetTitleDefault(void* ptr, char* vqs)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::setTitle(QString(vqs));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setTitle(QString(vqs));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::setTitle(QString(vqs));
	}
}

void QWindow_SetTransientParent(void* ptr, void* parent)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
			static_cast<QPaintDeviceWindow*>(ptr)->setTransientParent(static_cast<QPaintDeviceWindow*>(parent));
		} else {
			static_cast<QPaintDeviceWindow*>(ptr)->setTransientParent(static_cast<QWindow*>(parent));
		}
	} else {
		if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
			static_cast<QWindow*>(ptr)->setTransientParent(static_cast<QPaintDeviceWindow*>(parent));
		} else {
			static_cast<QWindow*>(ptr)->setTransientParent(static_cast<QWindow*>(parent));
		}
	}
}

void QWindow_SetVisibility(void* ptr, long long v)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setVisibility(static_cast<QWindow::Visibility>(v));
	} else {
		static_cast<QWindow*>(ptr)->setVisibility(static_cast<QWindow::Visibility>(v));
	}
}

void QWindow_SetVisible(void* ptr, char visible)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setVisible", Q_ARG(bool, visible != 0));
	}
}

void QWindow_SetVisibleDefault(void* ptr, char visible)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::setVisible(visible != 0);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setVisible(visible != 0);
	} else {
		static_cast<QWindow*>(ptr)->QWindow::setVisible(visible != 0);
	}
}

void QWindow_SetWidth(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setWidth", Q_ARG(int, arg));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setWidth", Q_ARG(int, arg));
	}
}

void QWindow_SetWidthDefault(void* ptr, int arg)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::setWidth(arg);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setWidth(arg);
	} else {
		static_cast<QWindow*>(ptr)->QWindow::setWidth(arg);
	}
}

void QWindow_SetWindowState(void* ptr, long long state)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->setWindowState(static_cast<Qt::WindowState>(state));
	} else {
		static_cast<QWindow*>(ptr)->setWindowState(static_cast<Qt::WindowState>(state));
	}
}

void QWindow_SetX(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setX", Q_ARG(int, arg));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setX", Q_ARG(int, arg));
	}
}

void QWindow_SetXDefault(void* ptr, int arg)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::setX(arg);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setX(arg);
	} else {
		static_cast<QWindow*>(ptr)->QWindow::setX(arg);
	}
}

void QWindow_SetY(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "setY", Q_ARG(int, arg));
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "setY", Q_ARG(int, arg));
	}
}

void QWindow_SetYDefault(void* ptr, int arg)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::setY(arg);
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::setY(arg);
	} else {
		static_cast<QWindow*>(ptr)->QWindow::setY(arg);
	}
}

void QWindow_Show(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "show");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "show");
	}
}

void QWindow_ShowDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::show();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::show();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::show();
	}
}

void QWindow_ShowEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->showEvent(static_cast<QShowEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->showEvent(static_cast<QShowEvent*>(ev));
	}
}

void QWindow_ShowEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::showEvent(static_cast<QShowEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::showEvent(static_cast<QShowEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::showEvent(static_cast<QShowEvent*>(ev));
	}
}

void QWindow_ShowFullScreen(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "showFullScreen");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "showFullScreen");
	}
}

void QWindow_ShowFullScreenDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::showFullScreen();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::showFullScreen();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::showFullScreen();
	}
}

void QWindow_ShowMaximized(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "showMaximized");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "showMaximized");
	}
}

void QWindow_ShowMaximizedDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::showMaximized();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::showMaximized();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::showMaximized();
	}
}

void QWindow_ShowMinimized(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "showMinimized");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "showMinimized");
	}
}

void QWindow_ShowMinimizedDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::showMinimized();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::showMinimized();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::showMinimized();
	}
}

void QWindow_ShowNormal(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "showNormal");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "showNormal");
	}
}

void QWindow_ShowNormalDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::showNormal();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::showNormal();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::showNormal();
	}
}

void QWindow_TabletEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->tabletEvent(static_cast<QTabletEvent*>(ev));
	}
}

void QWindow_TabletEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::tabletEvent(static_cast<QTabletEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::tabletEvent(static_cast<QTabletEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::tabletEvent(static_cast<QTabletEvent*>(ev));
	}
}

void QWindow_TouchEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->touchEvent(static_cast<QTouchEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->touchEvent(static_cast<QTouchEvent*>(ev));
	}
}

void QWindow_TouchEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::touchEvent(static_cast<QTouchEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::touchEvent(static_cast<QTouchEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::touchEvent(static_cast<QTouchEvent*>(ev));
	}
}

void QWindow_UnsetCursor(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->unsetCursor();
	} else {
		static_cast<QWindow*>(ptr)->unsetCursor();
	}
}

void QWindow_ConnectVisibilityChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QWindow::Visibility)>(&QWindow::visibilityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QWindow::Visibility)>(&MyQWindow::Signal_VisibilityChanged));
}

void QWindow_DisconnectVisibilityChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(QWindow::Visibility)>(&QWindow::visibilityChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(QWindow::Visibility)>(&MyQWindow::Signal_VisibilityChanged));
}

void QWindow_VisibilityChanged(void* ptr, long long visibility)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->visibilityChanged(static_cast<QWindow::Visibility>(visibility));
	} else {
		static_cast<QWindow*>(ptr)->visibilityChanged(static_cast<QWindow::Visibility>(visibility));
	}
}

void QWindow_ConnectVisibleChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(bool)>(&QWindow::visibleChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(bool)>(&MyQWindow::Signal_VisibleChanged));
}

void QWindow_DisconnectVisibleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(bool)>(&QWindow::visibleChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(bool)>(&MyQWindow::Signal_VisibleChanged));
}

void QWindow_VisibleChanged(void* ptr, char arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->visibleChanged(arg != 0);
	} else {
		static_cast<QWindow*>(ptr)->visibleChanged(arg != 0);
	}
}

void QWindow_WheelEvent(void* ptr, void* ev)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(ev));
	}
}

void QWindow_WheelEventDefault(void* ptr, void* ev)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::wheelEvent(static_cast<QWheelEvent*>(ev));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::wheelEvent(static_cast<QWheelEvent*>(ev));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::wheelEvent(static_cast<QWheelEvent*>(ev));
	}
}

void QWindow_ConnectWidthChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::widthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_WidthChanged));
}

void QWindow_DisconnectWidthChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::widthChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_WidthChanged));
}

void QWindow_WidthChanged(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->widthChanged(arg);
	} else {
		static_cast<QWindow*>(ptr)->widthChanged(arg);
	}
}

void QWindow_ConnectWindowStateChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::WindowState)>(&QWindow::windowStateChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::WindowState)>(&MyQWindow::Signal_WindowStateChanged));
}

void QWindow_DisconnectWindowStateChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(Qt::WindowState)>(&QWindow::windowStateChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(Qt::WindowState)>(&MyQWindow::Signal_WindowStateChanged));
}

void QWindow_WindowStateChanged(void* ptr, long long windowState)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->windowStateChanged(static_cast<Qt::WindowState>(windowState));
	} else {
		static_cast<QWindow*>(ptr)->windowStateChanged(static_cast<Qt::WindowState>(windowState));
	}
}

void QWindow_ConnectWindowTitleChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(const QString &)>(&QWindow::windowTitleChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(const QString &)>(&MyQWindow::Signal_WindowTitleChanged));
}

void QWindow_DisconnectWindowTitleChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(const QString &)>(&QWindow::windowTitleChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(const QString &)>(&MyQWindow::Signal_WindowTitleChanged));
}

void QWindow_WindowTitleChanged(void* ptr, char* title)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->windowTitleChanged(QString(title));
	} else {
		static_cast<QWindow*>(ptr)->windowTitleChanged(QString(title));
	}
}

void QWindow_ConnectXChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::xChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_XChanged));
}

void QWindow_DisconnectXChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::xChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_XChanged));
}

void QWindow_XChanged(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->xChanged(arg);
	} else {
		static_cast<QWindow*>(ptr)->xChanged(arg);
	}
}

void QWindow_ConnectYChanged(void* ptr)
{
	QObject::connect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::yChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_YChanged));
}

void QWindow_DisconnectYChanged(void* ptr)
{
	QObject::disconnect(static_cast<QWindow*>(ptr), static_cast<void (QWindow::*)(int)>(&QWindow::yChanged), static_cast<MyQWindow*>(ptr), static_cast<void (MyQWindow::*)(int)>(&MyQWindow::Signal_YChanged));
}

void QWindow_YChanged(void* ptr, int arg)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->yChanged(arg);
	} else {
		static_cast<QWindow*>(ptr)->yChanged(arg);
	}
}

void QWindow_DestroyQWindow(void* ptr)
{
	static_cast<QWindow*>(ptr)->~QWindow();
}

void QWindow_DestroyQWindowDefault(void* ptr)
{

}

void* QWindow_Cursor(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QCursor(static_cast<QPaintDeviceWindow*>(ptr)->cursor());
	} else {
		return new QCursor(static_cast<QWindow*>(ptr)->cursor());
	}
}

void* QWindow_Icon(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QIcon(static_cast<QPaintDeviceWindow*>(ptr)->icon());
	} else {
		return new QIcon(static_cast<QWindow*>(ptr)->icon());
	}
}

void* QWindow_FrameMargins(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QMargins tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->frameMargins(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
	} else {
		return ({ QMargins tmpValue = static_cast<QWindow*>(ptr)->frameMargins(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
	}
}

void* QWindow_FocusObject(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->focusObject();
	} else {
		return static_cast<QWindow*>(ptr)->focusObject();
	}
}

void* QWindow_FocusObjectDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRasterWindow*>(ptr)->QRasterWindow::focusObject();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::focusObject();
	} else {
		return static_cast<QWindow*>(ptr)->QWindow::focusObject();
	}
}

void* QWindow_FramePosition(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QPoint tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->framePosition(); new QPoint(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPoint tmpValue = static_cast<QWindow*>(ptr)->framePosition(); new QPoint(tmpValue.x(), tmpValue.y()); });
	}
}

void* QWindow_MapFromGlobal(void* ptr, void* pos)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QPoint tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->mapFromGlobal(*static_cast<QPoint*>(pos)); new QPoint(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPoint tmpValue = static_cast<QWindow*>(ptr)->mapFromGlobal(*static_cast<QPoint*>(pos)); new QPoint(tmpValue.x(), tmpValue.y()); });
	}
}

void* QWindow_MapToGlobal(void* ptr, void* pos)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QPoint tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->mapToGlobal(*static_cast<QPoint*>(pos)); new QPoint(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPoint tmpValue = static_cast<QWindow*>(ptr)->mapToGlobal(*static_cast<QPoint*>(pos)); new QPoint(tmpValue.x(), tmpValue.y()); });
	}
}

void* QWindow_Position(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QPoint tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->position(); new QPoint(tmpValue.x(), tmpValue.y()); });
	} else {
		return ({ QPoint tmpValue = static_cast<QWindow*>(ptr)->position(); new QPoint(tmpValue.x(), tmpValue.y()); });
	}
}

void* QWindow_FrameGeometry(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->frameGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QWindow*>(ptr)->frameGeometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QWindow_Geometry(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QRect tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QRect tmpValue = static_cast<QWindow*>(ptr)->geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
	}
}

void* QWindow_Mask(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QRegion(static_cast<QPaintDeviceWindow*>(ptr)->mask());
	} else {
		return new QRegion(static_cast<QWindow*>(ptr)->mask());
	}
}

void* QWindow_Screen(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->screen();
	} else {
		return static_cast<QWindow*>(ptr)->screen();
	}
}

void* QWindow_BaseSize(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->baseSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->baseSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QWindow_MaximumSize(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QWindow_MinimumSize(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QWindow_Size(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QWindow_SizeDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QRasterWindow*>(ptr)->QRasterWindow::size(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::size(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->QWindow::size(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

void* QWindow_SizeIncrement(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QSize tmpValue = static_cast<QPaintDeviceWindow*>(ptr)->sizeIncrement(); new QSize(tmpValue.width(), tmpValue.height()); });
	} else {
		return ({ QSize tmpValue = static_cast<QWindow*>(ptr)->sizeIncrement(); new QSize(tmpValue.width(), tmpValue.height()); });
	}
}

struct QtGui_PackedString QWindow_FilePath(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QByteArray t7116fb = static_cast<QPaintDeviceWindow*>(ptr)->filePath().toUtf8(); QtGui_PackedString { const_cast<char*>(t7116fb.prepend("WHITESPACE").constData()+10), t7116fb.size()-10 }; });
	} else {
		return ({ QByteArray t7116fb = static_cast<QWindow*>(ptr)->filePath().toUtf8(); QtGui_PackedString { const_cast<char*>(t7116fb.prepend("WHITESPACE").constData()+10), t7116fb.size()-10 }; });
	}
}

struct QtGui_PackedString QWindow_Title(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return ({ QByteArray t3f590b = static_cast<QPaintDeviceWindow*>(ptr)->title().toUtf8(); QtGui_PackedString { const_cast<char*>(t3f590b.prepend("WHITESPACE").constData()+10), t3f590b.size()-10 }; });
	} else {
		return ({ QByteArray t3f590b = static_cast<QWindow*>(ptr)->title().toUtf8(); QtGui_PackedString { const_cast<char*>(t3f590b.prepend("WHITESPACE").constData()+10), t3f590b.size()-10 }; });
	}
}

void* QWindow_Format(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QSurfaceFormat(static_cast<QPaintDeviceWindow*>(ptr)->format());
	} else {
		return new QSurfaceFormat(static_cast<QWindow*>(ptr)->format());
	}
}

void* QWindow_FormatDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		return new QSurfaceFormat(static_cast<QRasterWindow*>(ptr)->QRasterWindow::format());
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QSurfaceFormat(static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::format());
	} else {
		return new QSurfaceFormat(static_cast<QWindow*>(ptr)->QWindow::format());
	}
}

void* QWindow_RequestedFormat(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QSurfaceFormat(static_cast<QPaintDeviceWindow*>(ptr)->requestedFormat());
	} else {
		return new QSurfaceFormat(static_cast<QWindow*>(ptr)->requestedFormat());
	}
}

void* QWindow_Parent(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->parent();
	} else {
		return static_cast<QWindow*>(ptr)->parent();
	}
}

void* QWindow_TransientParent(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->transientParent();
	} else {
		return static_cast<QWindow*>(ptr)->transientParent();
	}
}

long long QWindow_ContentOrientation(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->contentOrientation();
	} else {
		return static_cast<QWindow*>(ptr)->contentOrientation();
	}
}

long long QWindow_Flags(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->flags();
	} else {
		return static_cast<QWindow*>(ptr)->flags();
	}
}

long long QWindow_Modality(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->modality();
	} else {
		return static_cast<QWindow*>(ptr)->modality();
	}
}

long long QWindow_WindowState(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->windowState();
	} else {
		return static_cast<QWindow*>(ptr)->windowState();
	}
}

long long QWindow_Type(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->type();
	} else {
		return static_cast<QWindow*>(ptr)->type();
	}
}

long long QWindow_SurfaceType(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->surfaceType();
	} else {
		return static_cast<QWindow*>(ptr)->surfaceType();
	}
}

long long QWindow_SurfaceTypeDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QRasterWindow*>(ptr)->QRasterWindow::surfaceType();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::surfaceType();
	} else {
		return static_cast<QWindow*>(ptr)->QWindow::surfaceType();
	}
}

long long QWindow_Visibility(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->visibility();
	} else {
		return static_cast<QWindow*>(ptr)->visibility();
	}
}

uintptr_t QWindow_WinId(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->winId();
	} else {
		return static_cast<QWindow*>(ptr)->winId();
	}
}

char QWindow_IsActive(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->isActive();
	} else {
		return static_cast<QWindow*>(ptr)->isActive();
	}
}

char QWindow_IsAncestorOf(void* ptr, void* child, long long mode)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(child))) {
			return static_cast<QPaintDeviceWindow*>(ptr)->isAncestorOf(static_cast<QPaintDeviceWindow*>(child), static_cast<QWindow::AncestorMode>(mode));
		} else {
			return static_cast<QPaintDeviceWindow*>(ptr)->isAncestorOf(static_cast<QWindow*>(child), static_cast<QWindow::AncestorMode>(mode));
		}
	} else {
		if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(child))) {
			return static_cast<QWindow*>(ptr)->isAncestorOf(static_cast<QPaintDeviceWindow*>(child), static_cast<QWindow::AncestorMode>(mode));
		} else {
			return static_cast<QWindow*>(ptr)->isAncestorOf(static_cast<QWindow*>(child), static_cast<QWindow::AncestorMode>(mode));
		}
	}
}

char QWindow_IsExposed(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->isExposed();
	} else {
		return static_cast<QWindow*>(ptr)->isExposed();
	}
}

char QWindow_IsModal(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->isModal();
	} else {
		return static_cast<QWindow*>(ptr)->isModal();
	}
}

char QWindow_IsTopLevel(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->isTopLevel();
	} else {
		return static_cast<QWindow*>(ptr)->isTopLevel();
	}
}

char QWindow_IsVisible(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->isVisible();
	} else {
		return static_cast<QWindow*>(ptr)->isVisible();
	}
}

int QWindow_Height(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->height();
	} else {
		return static_cast<QWindow*>(ptr)->height();
	}
}

int QWindow_MaximumHeight(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->maximumHeight();
	} else {
		return static_cast<QWindow*>(ptr)->maximumHeight();
	}
}

int QWindow_MaximumWidth(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->maximumWidth();
	} else {
		return static_cast<QWindow*>(ptr)->maximumWidth();
	}
}

int QWindow_MinimumHeight(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->minimumHeight();
	} else {
		return static_cast<QWindow*>(ptr)->minimumHeight();
	}
}

int QWindow_MinimumWidth(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->minimumWidth();
	} else {
		return static_cast<QWindow*>(ptr)->minimumWidth();
	}
}

int QWindow_Width(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->width();
	} else {
		return static_cast<QWindow*>(ptr)->width();
	}
}

int QWindow_X(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->x();
	} else {
		return static_cast<QWindow*>(ptr)->x();
	}
}

int QWindow_Y(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->y();
	} else {
		return static_cast<QWindow*>(ptr)->y();
	}
}

double QWindow_DevicePixelRatio(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->devicePixelRatio();
	} else {
		return static_cast<QWindow*>(ptr)->devicePixelRatio();
	}
}

double QWindow_Opacity(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return static_cast<QPaintDeviceWindow*>(ptr)->opacity();
	} else {
		return static_cast<QWindow*>(ptr)->opacity();
	}
}

void* QWindow___dynamicPropertyNames_atList(void* ptr, int i)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
	} else {
		return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
	}
}

void QWindow___dynamicPropertyNames_setList(void* ptr, void* i)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
	} else {
		static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
	}
}

void* QWindow___dynamicPropertyNames_newList(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QList<QByteArray>;
	} else {
		return new QList<QByteArray>;
	}
}

void* QWindow___findChildren_atList2(void* ptr, int i)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
	} else {
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
	}
}

void QWindow___findChildren_setList2(void* ptr, void* i)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
		} else {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
		}
	} else {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
		} else {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
		}
	}
}

void* QWindow___findChildren_newList2(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QList<QObject*>;
	} else {
		return new QList<QObject*>;
	}
}

void* QWindow___findChildren_atList3(void* ptr, int i)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
	} else {
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
	}
}

void QWindow___findChildren_setList3(void* ptr, void* i)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
		} else {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
		}
	} else {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
		} else {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
		}
	}
}

void* QWindow___findChildren_newList3(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QList<QObject*>;
	} else {
		return new QList<QObject*>;
	}
}

void* QWindow___findChildren_atList(void* ptr, int i)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
	} else {
		return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
	}
}

void QWindow___findChildren_setList(void* ptr, void* i)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
		} else {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
		}
	} else {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QPdfWriter*>(i));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QWindow*>(i));
		} else {
			static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
		}
	}
}

void* QWindow___findChildren_newList(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QList<QObject*>;
	} else {
		return new QList<QObject*>;
	}
}

void* QWindow___children_atList(void* ptr, int i)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
	} else {
		return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
	}
}

void QWindow___children_setList(void* ptr, void* i)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
		} else {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
		}
	} else {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QOffscreenSurface*>(i));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPaintDeviceWindow*>(i));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QPdfWriter*>(i));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(i))) {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QWindow*>(i));
		} else {
			static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
		}
	}
}

void* QWindow___children_newList(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return new QList<QObject *>;
	} else {
		return new QList<QObject *>;
	}
}

char QWindow_EventFilter(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QPaintDeviceWindow*>(ptr)->eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QPaintDeviceWindow*>(ptr)->eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QPaintDeviceWindow*>(ptr)->eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QPaintDeviceWindow*>(ptr)->eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QPaintDeviceWindow*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QWindow*>(ptr)->eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QWindow*>(ptr)->eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QWindow*>(ptr)->eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QWindow*>(ptr)->eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QWindow*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

char QWindow_EventFilterDefault(void* ptr, void* watched, void* event)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QRasterWindow*>(ptr)->QRasterWindow::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QRasterWindow*>(ptr)->QRasterWindow::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QRasterWindow*>(ptr)->QRasterWindow::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QRasterWindow*>(ptr)->QRasterWindow::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QRasterWindow*>(ptr)->QRasterWindow::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	} else {
		if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(watched))) {
			return static_cast<QWindow*>(ptr)->QWindow::eventFilter(static_cast<QOffscreenSurface*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QWindow*>(ptr)->QWindow::eventFilter(static_cast<QPaintDeviceWindow*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(watched))) {
			return static_cast<QWindow*>(ptr)->QWindow::eventFilter(static_cast<QPdfWriter*>(watched), static_cast<QEvent*>(event));
		} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(watched))) {
			return static_cast<QWindow*>(ptr)->QWindow::eventFilter(static_cast<QWindow*>(watched), static_cast<QEvent*>(event));
		} else {
			return static_cast<QWindow*>(ptr)->QWindow::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
		}
	}
}

void QWindow_ChildEvent(void* ptr, void* event)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QWindow*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
	}
}

void QWindow_ChildEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::childEvent(static_cast<QChildEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::childEvent(static_cast<QChildEvent*>(event));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::childEvent(static_cast<QChildEvent*>(event));
	}
}

void QWindow_ConnectNotify(void* ptr, void* sign)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QWindow*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QWindow_ConnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::connectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QWindow_CustomEvent(void* ptr, void* event)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QWindow*>(ptr)->customEvent(static_cast<QEvent*>(event));
	}
}

void QWindow_CustomEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::customEvent(static_cast<QEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::customEvent(static_cast<QEvent*>(event));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::customEvent(static_cast<QEvent*>(event));
	}
}

void QWindow_DeleteLater(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		QMetaObject::invokeMethod(static_cast<QPaintDeviceWindow*>(ptr), "deleteLater");
	} else {
		QMetaObject::invokeMethod(static_cast<QWindow*>(ptr), "deleteLater");
	}
}

void QWindow_DeleteLaterDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::deleteLater();
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::deleteLater();
	} else {
		static_cast<QWindow*>(ptr)->QWindow::deleteLater();
	}
}

void QWindow_DisconnectNotify(void* ptr, void* sign)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QWindow*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QWindow_DisconnectNotifyDefault(void* ptr, void* sign)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::disconnectNotify(*static_cast<QMetaMethod*>(sign));
	}
}

void QWindow_TimerEvent(void* ptr, void* event)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QWindow*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
	}
}

void QWindow_TimerEventDefault(void* ptr, void* event)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QRasterWindow*>(ptr)->QRasterWindow::timerEvent(static_cast<QTimerEvent*>(event));
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::timerEvent(static_cast<QTimerEvent*>(event));
	} else {
		static_cast<QWindow*>(ptr)->QWindow::timerEvent(static_cast<QTimerEvent*>(event));
	}
}

void* QWindow_MetaObject(void* ptr)
{
	if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QPaintDeviceWindow*>(ptr)->metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QWindow*>(ptr)->metaObject());
	}
}

void* QWindow_MetaObjectDefault(void* ptr)
{
	if (dynamic_cast<QRasterWindow*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QRasterWindow*>(ptr)->QRasterWindow::metaObject());
	} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(ptr))) {
		return const_cast<QMetaObject*>(static_cast<QPaintDeviceWindow*>(ptr)->QPaintDeviceWindow::metaObject());
	} else {
		return const_cast<QMetaObject*>(static_cast<QWindow*>(ptr)->QWindow::metaObject());
	}
}

class MyQWindowStateChangeEvent: public QWindowStateChangeEvent
{
public:
};

long long QWindowStateChangeEvent_OldState(void* ptr)
{
	return static_cast<QWindowStateChangeEvent*>(ptr)->oldState();
}